密码学 二

已于 2023-12-29 17:10:14 修改
阅读量848 收藏 15
点赞数 16
分类专栏： 算法 文章标签： 密码学 算法
于 2023-12-29 17:09:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34837666/article/details/135295207
版权

编写ElGamal签名程序

【问题描述】

ElGamal签名是一种数字签名算法，它基于ElGamal加密算法的数学原理。ElGamal签名是一种公钥密码学技术，用于验证数据的完整性和真实性，确保数据在传输或存储过程中没有被篡改。

ElGamal签名的生成和验证过程， 密钥生成：

需要生成一对ElGamal的密钥对，包括私钥（d）和公钥（e1、p）。 签名生成：

计算e2 = e1^d mod p，其中e2是签名者使用私钥生成的一部分。 计算s1 = e1^r mod p，其中s1是签名者使用私钥生成的一部分。 计算s2 = (((m - d * s1) % (p-1)) * ModInv(r, p-1)) % (p-1)，这是签名者使用私钥生成的一部分。 计算v1 = e1^m mod p，其中v1是签名者使用私钥生成的一部分。 计算a = e2^s1 mod p，以及b = s1^s2 mod p，这两个值也是签名者使用私钥生成的一部分。 计算v2 = (a * b) % p，这是签名者使用私钥生成的一部分。 签名验证：

验证者需要知道p、e1、r以及收到的签名值(s1, s2, v1, v2)。 使用公开的参数p、e1、r和收到的签名值计算v1，即v1 = e1^m mod p。 使用ModInv函数计算s2的模逆。 使用计算的模逆和公开的参数计算s1，即s1 = e1^r mod p。 使用公开的参数p、e1、s1、s2、v1和v2来计算a和b。 验证签名的有效性：如果v2等于v1，则签名有效，否则签名无效。

本步骤要求实验者实现一个名为elgamalsign.cpp的C++程序，要求输入代表p, e1, d, m和r的数字，要求输出v1

#./elgamalsign
3119
2
127
3000 
107
704

【输入形式】

p

e1

d

m

r
【输出形式】

v1
【样例输入】

3119
2
127
3000 
107

【样例输出】

704


def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('')
    else:
        return x % m

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y

def elgamal_sign(p, e1, d, m, r):
    v1 = pow(e1, m, p)
    return v1


p = int(input())
e1 = int(input())
d = int(input())
m = int(input())
r = int(input())

v1 = elgamal_sign(p, e1, d, m, r)
print( v1)

编写ElGamal解密程序

【问题描述】

ElGamal加密算法包含两个主要部分：加密和解密。以下是ElGamal加密算法的基本步骤：

密钥生成：

随机选择一个大素数p。 随机选择一个小于p的整数g，称为生成元。 随机选择一个私钥x，它是一个小于p-1的整数。 计算公钥y = g^x mod p，其中^表示乘方运算，mod表示取模运算。 公开p、g和y，但保持x秘密。 加密：

随机选择一个临时私钥k，它是一个小于p-1的整数。 计算临时公钥C1 = g^k mod p。 计算共享密钥s = y^k mod p。 将消息m与共享密钥s进行异或运算，得到密文C2。 密文为(C1, C2)，发送给接收者。 解密：

接收到密文(C1, C2)。 使用私钥x计算共享密钥s = C1^x mod p。 将密文C2除以共享密钥s，得到原始消息m。

在给定p=307，x=67，g=2的前提下，给定C1和C2（root目录下的cipher1.txt和cipher2.txt），要求编写/root/目录下的解密程序elgamaldec，要求还原出明文。

#cat cipher1.txt
125 77 3 163 237 205 216 167 162 51 289 2 205 155 17
#cat cipher2.txt
87 114 243 46 59 303 63 151 198 72 93 14 303 143 170
#./elgamaldec
test.educg.net

【输入形式】

cipher1.txt文件 cipher2.txt文件

【输出形式】

解密字符串

【样例输入】

#cat cipher1.txt
125 77 3 163 237 205 216 167 162 51 289 2 205 155 17
#cat cipher2.txt
87 114 243 46 59 303 63 151 198 72 93 14 303 143 170

【样例输出】

test.educg.net

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <cmath>
using namespace std;
long long modinv(long long a, long long m)
{
  long long m0 = m, t, q;
  long long x0 = 0, x1 = 1;
  if (m == 1)
    return 0;
  while (a > 1)
  {
    q = a / m;
    t = m;
    m = a % m, a = t;
    t = x0;
    x0 = x1 - q * x0;
    x1 = t;
  }
  if (x1 < 0)
    x1 += m0;
  return x1;
}

vector<int> readCipher(const string &filename)
{
  vector<int> cipher;
  ifstream file(filename);
  string line;
  if (file.is_open())
  {
    while (getline(file, line))
    {
      stringstream ss(line);
      int num;
      while (ss >> num)
      {
        cipher.push_back(num);
      }
    }
    file.close();
  }
  return cipher;
}

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

string elgamalDecrypt(const vector<int> &c1, const vector<int> &c2, int p, int x) {
    string decrypted;
    for (size_t i = 0; i < c1.size(); ++i) {
        long long s = modPow(c1[i], x, p);
        long long inverse_s = modinv(s, p);
        long long m = (c2[i] * inverse_s) % p;
        decrypted.push_back(static_cast<char>(m));
    }
    return decrypted;
}

int main()
{
  const int p = 307;
  const int x = 67;

  vector<int> c1 = readCipher("cipher1.txt");
  vector<int> c2 = readCipher("cipher2.txt");

  string decrypted = elgamalDecrypt(c1, c2, p, x);

  cout << decrypted << endl;

  return 0;
}

大数运算基础

【问题描述】

1、大数运算

由于编程语言提供的基本数值数据类型表示的数值范围有限，不能满足较大规模的高精度数值计算，因此需要利用其他方法实现高精度数值的计算，于是产生了大数运算。大数运算主要有加、减、乘等方法。大数运算是现代密码学的重要基础。

既然在计算机中无法直接表示，那么大数到底如何进行运算呢，学习过数据结构的都知道线性表（数组），将大数拆分然后存储在线性表中，不失为一个很好的办法。

利用数组连续性，将大数每一位上的数字单独取出放入对应的数组格中，然后再对每一位做单独的加减乘运算。形象的说，类似于小学学习加减乘所列的式子。

2、本作业需要完成的任务

本作业需要完成的任务是利用bignum_init（大数初始化），bignum_from_int（把整数转换成大数）、_lshift_word（大数左移）、bignum_add（大数加）等补充函数bignum_mul，以完成大数乘积运算。

【输入形式】

十六进制表示的第一个乘数（第二个乘数在程序中默认给出）
【输出形式】

十六进制表示的乘积
【样例输入】

1f233b47

【样例输出】

7b4f4a5794944bed1c4d399

#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>

/* This macro defines the word size in bytes of the array that constitues the big-number data structure. */
#ifndef WORD_SIZE
  #define WORD_SIZE 4
#endif

/* Size of big-numbers in bytes */
#define BN_ARRAY_SIZE    (128 / WORD_SIZE)


/* Here comes the compile-time specialization for how large the underlying array size should be. */
/* The choices are 1, 2 and 4 bytes in size with uint32, uint64 for WORD_SIZE==4, as temporary. */
#ifndef WORD_SIZE
  #error Must define WORD_SIZE to be 1, 2, 4
#elif (WORD_SIZE == 1)
  /* Data type of array in structure */
  #define DTYPE                    uint8_t
  /* bitmask for getting MSB */
  #define DTYPE_MSB                ((DTYPE_TMP)(0x80))
  /* Data-type larger than DTYPE, for holding intermediate results of calculations */
  #define DTYPE_TMP                uint32_t
  /* sprintf format string */
  #define SPRINTF_FORMAT_STR       "%.02x"
  #define SSCANF_FORMAT_STR        "%2hhx"
  /* Max value of integer type */
  #define MAX_VAL                  ((DTYPE_TMP)0xFF)
#elif (WORD_SIZE == 2)
  #define DTYPE                    uint16_t
  #define DTYPE_TMP                uint32_t
  #define DTYPE_MSB                ((DTYPE_TMP)(0x8000))
  #define SPRINTF_FORMAT_STR       "%.04x"
  #define SSCANF_FORMAT_STR        "%4hx"
  #define MAX_VAL                  ((DTYPE_TMP)0xFFFF)
#elif (WORD_SIZE == 4)
  #define DTYPE                    uint32_t
  #define DTYPE_TMP                uint64_t
  #define DTYPE_MSB                ((DTYPE_TMP)(0x80000000))
  #define SPRINTF_FORMAT_STR       "%.08x"
  #define SSCANF_FORMAT_STR        "%8x"
  #define MAX_VAL                  ((DTYPE_TMP)0xFFFFFFFF)
#endif
#ifndef DTYPE
  #error DTYPE must be defined to uint8_t, uint16_t uint32_t or whatever
#endif


/* Custom assert macro - easy to disable */
#define require(p, msg) assert(p && msg)


/* Data-holding structure: array of DTYPEs */
struct bn
{
  DTYPE array[BN_ARRAY_SIZE];
};



/* Tokens returned by bignum_cmp() for value comparison */
enum { SMALLER = -1, EQUAL = 0, LARGER = 1 };
void bignum_init(struct bn* n);
void bignum_from_int(struct bn* n, DTYPE_TMP i);
int  bignum_to_int(struct bn* n);
void bignum_from_string(struct bn* n, char* str, int nbytes);
void bignum_to_string(struct bn* n, char* str, int maxsize);

/* Basic arithmetic operations: */
void bignum_add(struct bn* a, struct bn* b, struct bn* c); /* c = a + b */
void bignum_sub(struct bn* a, struct bn* b, struct bn* c); /* c = a - b */
void bignum_mul(struct bn* a, struct bn* b, struct bn* c); /* c = a * b */
void bignum_div(struct bn* a, struct bn* b, struct bn* c); /* c = a / b */
void bignum_mod(struct bn* a, struct bn* b, struct bn* c); /* c = a % b */
void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d); /* c = a/b, d = a%b */

/* Bitwise operations: */
void bignum_and(struct bn* a, struct bn* b, struct bn* c); /* c = a & b */
void bignum_or(struct bn* a, struct bn* b, struct bn* c);  /* c = a | b */
void bignum_xor(struct bn* a, struct bn* b, struct bn* c); /* c = a ^ b */
void bignum_lshift(struct bn* a, struct bn* b, int nbits); /* b = a << nbits */
void bignum_rshift(struct bn* a, struct bn* b, int nbits); /* b = a >> nbits */

/* Special operators and comparison */
int  bignum_cmp(struct bn* a, struct bn* b);               /* Compare: returns LARGER, EQUAL or SMALLER */
int  bignum_is_zero(struct bn* n);                         /* For comparison with zero */
void bignum_inc(struct bn* n);                             /* Increment: add one to n */
void bignum_dec(struct bn* n);                             /* Decrement: subtract one from n */
void bignum_pow(struct bn* a, struct bn* b, struct bn* c); /* Calculate a^b -- e.g. 2^10 => 1024 */
void bignum_isqrt(struct bn* a, struct bn* b);             /* Integer square root -- e.g. isqrt(5) => 2*/
void bignum_assign(struct bn* dst, struct bn* src);        /* Copy src into dst -- dst := src */


/* Functions for shifting number in-place. */
static void _lshift_one_bit(struct bn* a);
static void _rshift_one_bit(struct bn* a);
static void _lshift_word(struct bn* a, int nwords);
static void _rshift_word(struct bn* a, int nwords);



/* Public / Exported functions. */
void bignum_init(struct bn* n)
{
  require(n, "n is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    n->array[i] = 0;
  }
}


void bignum_from_int(struct bn* n, DTYPE_TMP i)
{
  require(n, "n is null");

  bignum_init(n);

  /* Endianness issue if machine is not little-endian? */
#ifdef WORD_SIZE
 #if (WORD_SIZE == 1)
  n->array[0] = (i & 0x000000ff);
  n->array[1] = (i & 0x0000ff00) >> 8;
  n->array[2] = (i & 0x00ff0000) >> 16;
  n->array[3] = (i & 0xff000000) >> 24;
 #elif (WORD_SIZE == 2)
  n->array[0] = (i & 0x0000ffff);
  n->array[1] = (i & 0xffff0000) >> 16;
 #elif (WORD_SIZE == 4)
  n->array[0] = i;
  DTYPE_TMP num_32 = 32;
  DTYPE_TMP tmp = i >> num_32; /* bit-shift with U64 operands to force 64-bit results */
  n->array[1] = tmp;
 #endif
#endif
}


int bignum_to_int(struct bn* n)
{
  require(n, "n is null");

  int ret = 0;

  /* Endianness issue if machine is not little-endian? */
#if (WORD_SIZE == 1)
  ret += n->array[0];
  ret += n->array[1] << 8;
  ret += n->array[2] << 16;
  ret += n->array[3] << 24;  
#elif (WORD_SIZE == 2)
  ret += n->array[0];
  ret += n->array[1] << 16;
#elif (WORD_SIZE == 4)
  ret += n->array[0];
#endif

  return ret;
}


void bignum_from_string(struct bn* n, char* str, int nbytes)
{
  require(n, "n is null");
  require(str, "str is null");
  require(nbytes > 0, "nbytes must be positive");
  require((nbytes & 1) == 0, "string format must be in hex -> equal number of bytes");
  require((nbytes % (sizeof(DTYPE) * 2)) == 0, "string length must be a multiple of (sizeof(DTYPE) * 2) characters");
  
  bignum_init(n);

  DTYPE tmp;                        /* DTYPE is defined in bn.h - uint{8,16,32,64}_t */
  int i = nbytes - (2 * WORD_SIZE); /* index into string */
  int j = 0;                        /* index into array */

  /* reading last hex-byte "MSB" from string first -> big endian */
  /* MSB ~= most significant byte / block ? :) */
  while (i >= 0)
  {
    tmp = 0;
    sscanf(&str[i], SSCANF_FORMAT_STR, &tmp);
    n->array[j] = tmp;
    i -= (2 * WORD_SIZE); /* step WORD_SIZE hex-byte(s) back in the string. */
    j += 1;               /* step one element forward in the array. */
  }
}


void bignum_to_string(struct bn* n, char* str, int nbytes)
{
  require(n, "n is null");
  require(str, "str is null");
  require(nbytes > 0, "nbytes must be positive");
  require((nbytes & 1) == 0, "string format must be in hex -> equal number of bytes");

  int j = BN_ARRAY_SIZE - 1; /* index into array - reading "MSB" first -> big-endian */
  int i = 0;                 /* index into string representation. */

  /* reading last array-element "MSB" first -> big endian */
  while ((j >= 0) && (nbytes > (i + 1)))
  {
    sprintf(&str[i], SPRINTF_FORMAT_STR, n->array[j]);
    i += (2 * WORD_SIZE); /* step WORD_SIZE hex-byte(s) forward in the string. */
    j -= 1;               /* step one element back in the array. */
  }

  /* Count leading zeros: */
  j = 0;
  while (str[j] == '0')
  {
    j += 1;
  }
 
  /* Move string j places ahead, effectively skipping leading zeros */ 
  for (i = 0; i < (nbytes - j); ++i)
  {
    str[i] = str[i + j];
  }

  /* Zero-terminate string */
  str[i] = 0;
}


void bignum_dec(struct bn* n)
{
  require(n, "n is null");

  DTYPE tmp; /* copy of n */
  DTYPE res;

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    tmp = n->array[i];
    res = tmp - 1;
    n->array[i] = res;

    if (!(res > tmp))
    {
      break;
    }
  }
}


void bignum_inc(struct bn* n)
{
  require(n, "n is null");

  DTYPE res;
  DTYPE_TMP tmp; /* copy of n */

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    tmp = n->array[i];
    res = tmp + 1;
    n->array[i] = res;

    if (res > tmp)
    {
      break;
    }
  }
}


void bignum_add(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  DTYPE_TMP tmp;
  int carry = 0;
  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    tmp = (DTYPE_TMP)a->array[i] + b->array[i] + carry;
    carry = (tmp > MAX_VAL);
    c->array[i] = (tmp & MAX_VAL);
  }
}


void bignum_sub(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  DTYPE_TMP res;
  DTYPE_TMP tmp1;
  DTYPE_TMP tmp2;
  int borrow = 0;
  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    tmp1 = (DTYPE_TMP)a->array[i] + (MAX_VAL + 1); /* + number_base */
    tmp2 = (DTYPE_TMP)b->array[i] + borrow;;
    res = (tmp1 - tmp2);
    c->array[i] = (DTYPE)(res & MAX_VAL); /* "modulo number_base" == "% (number_base - 1)" if number_base is 2^N */
    borrow = (res <= MAX_VAL);
  }
}


void bignum_mul(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  struct bn row;
  struct bn tmp;
  int i, j;

  bignum_init(c);

  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    bignum_init(&row);

    for (j = 0; j < BN_ARRAY_SIZE; ++j)
    {
      if (i + j < BN_ARRAY_SIZE)
      {
        bignum_init(&tmp);
        DTYPE_TMP intermediate = (DTYPE_TMP)a->array[i] * (DTYPE_TMP)b->array[j];
        bignum_from_int(&tmp, intermediate);
        _lshift_word(&tmp, i+j);
        bignum_add(&row, &tmp, &row);
      }
    }
    bignum_add(c, &row, c);
  }
}


void bignum_div(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  struct bn current;
  struct bn denom;
  struct bn tmp;

  bignum_from_int(¤t, 1);  // int current = 1;
  bignum_assign(&denom, b);      // denom = b
  bignum_assign(&tmp, a);        // tmp   = a

  const DTYPE_TMP half_max = 1 + (DTYPE_TMP)(MAX_VAL / 2);
  bool overflow = false;
  while (bignum_cmp(&denom, a) != LARGER)  // while (denom <= a) 
  {
    if (denom.array[BN_ARRAY_SIZE - 1] >= half_max)
    {
      overflow = true;
      break;
    }
    _lshift_one_bit(¤t);    //   current <<= 1;
    _lshift_one_bit(&denom);      //   denom <<= 1;
  }
  if (!overflow)
  {
    _rshift_one_bit(&denom);      // denom >>= 1;
    _rshift_one_bit(¤t);    // current >>= 1;
  }
  bignum_init(c);                // int answer = 0;

  while (!bignum_is_zero(¤t))  // while (current != 0)
  {
    if (bignum_cmp(&tmp, &denom) != SMALLER)  //   if (dividend >= denom)
    {
      bignum_sub(&tmp, &denom, &tmp);         //     dividend -= denom;
      bignum_or(c, ¤t, c);              //     answer |= current;
    }
    _rshift_one_bit(¤t);    //   current >>= 1;
    _rshift_one_bit(&denom);      //   denom >>= 1;
  }                                // return answer;
}

void bignum_lshift(struct bn* a, struct bn* b, int nbits)
{
  require(a, "a is null");
  require(b, "b is null");
  require(nbits >= 0, "no negative shifts");

  bignum_assign(b, a);
  /* Handle shift in multiples of word-size */
  const int nbits_pr_word = (WORD_SIZE * 8);
  int nwords = nbits / nbits_pr_word;
  if (nwords != 0)
  {
    _lshift_word(b, nwords);
    nbits -= (nwords * nbits_pr_word);
  }

  if (nbits != 0)
  {
    int i;
    for (i = (BN_ARRAY_SIZE - 1); i > 0; --i)
    {
      b->array[i] = (b->array[i] << nbits) | (b->array[i - 1] >> ((8 * WORD_SIZE) - nbits));
    }
    b->array[i] <<= nbits;
  }
}


void bignum_rshift(struct bn* a, struct bn* b, int nbits)
{
  require(a, "a is null");
  require(b, "b is null");
  require(nbits >= 0, "no negative shifts");
  
  bignum_assign(b, a);
  /* Handle shift in multiples of word-size */
  const int nbits_pr_word = (WORD_SIZE * 8);
  int nwords = nbits / nbits_pr_word;
  if (nwords != 0)
  {
    _rshift_word(b, nwords);
    nbits -= (nwords * nbits_pr_word);
  }

  if (nbits != 0)
  {
    int i;
    for (i = 0; i < (BN_ARRAY_SIZE - 1); ++i)
    {
      b->array[i] = (b->array[i] >> nbits) | (b->array[i + 1] << ((8 * WORD_SIZE) - nbits));
    }
    b->array[i] >>= nbits;
  }
  
}


void bignum_mod(struct bn* a, struct bn* b, struct bn* c)
{
  /*
    Take divmod and throw away div part
  */
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  struct bn tmp;

  bignum_divmod(a,b,&tmp,c);
}

void bignum_divmod(struct bn* a, struct bn* b, struct bn* c, struct bn* d)
{
  /*
    Puts a%b in d
    and a/b in c

    mod(a,b) = a - ((a / b) * b)

    example:
      mod(8, 3) = 8 - ((8 / 3) * 3) = 2
  */
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  struct bn tmp;

  /* c = (a / b) */
  bignum_div(a, b, c);

  /* tmp = (c * b) */
  bignum_mul(c, b, &tmp);

  /* c = a - tmp */
  bignum_sub(a, &tmp, d);
}


void bignum_and(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    c->array[i] = (a->array[i] & b->array[i]);
  }
}


void bignum_or(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    c->array[i] = (a->array[i] | b->array[i]);
  }
}


void bignum_xor(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    c->array[i] = (a->array[i] ^ b->array[i]);
  }
}


int bignum_cmp(struct bn* a, struct bn* b)
{
  require(a, "a is null");
  require(b, "b is null");

  int i = BN_ARRAY_SIZE;
  do
  {
    i -= 1; /* Decrement first, to start with last array element */
    if (a->array[i] > b->array[i])
    {
      return LARGER;
    }
    else if (a->array[i] < b->array[i])
    {
      return SMALLER;
    }
  }
  while (i != 0);

  return EQUAL;
}


int bignum_is_zero(struct bn* n)
{
  require(n, "n is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    if (n->array[i])
    {
      return 0;
    }
  }

  return 1;
}


void bignum_pow(struct bn* a, struct bn* b, struct bn* c)
{
  require(a, "a is null");
  require(b, "b is null");
  require(c, "c is null");

  struct bn tmp;

  bignum_init(c);

  if (bignum_cmp(b, c) == EQUAL)
  {
    /* Return 1 when exponent is 0 -- n^0 = 1 */
    bignum_inc(c);
  }
  else
  {
    struct bn bcopy;
    bignum_assign(&bcopy, b);

    /* Copy a -> tmp */
    bignum_assign(&tmp, a);

    bignum_dec(&bcopy);
 
    /* Begin summing products: */
    while (!bignum_is_zero(&bcopy))
    {

      /* c = tmp * tmp */
      bignum_mul(&tmp, a, c);
      /* Decrement b by one */
      bignum_dec(&bcopy);

      bignum_assign(&tmp, c);
    }

    /* c = tmp */
    bignum_assign(c, &tmp);
  }
}

void bignum_isqrt(struct bn *a, struct bn* b)
{
  require(a, "a is null");
  require(b, "b is null");

  struct bn low, high, mid, tmp;

  bignum_init(&low);
  bignum_assign(&high, a);
  bignum_rshift(&high, &mid, 1);
  bignum_inc(&mid);

  while (bignum_cmp(&high, &low) > 0) 
  {
    bignum_mul(&mid, &mid, &tmp);
    if (bignum_cmp(&tmp, a) > 0) 
    {
      bignum_assign(&high, &mid);
      bignum_dec(&high);
    }
    else 
    {
      bignum_assign(&low, &mid);
    }
    bignum_sub(&high,&low,&mid);
    _rshift_one_bit(&mid);
    bignum_add(&low,&mid,&mid);
    bignum_inc(&mid);
  }
  bignum_assign(b,&low);
}


void bignum_assign(struct bn* dst, struct bn* src)
{
  require(dst, "dst is null");
  require(src, "src is null");

  int i;
  for (i = 0; i < BN_ARRAY_SIZE; ++i)
  {
    dst->array[i] = src->array[i];
  }
}


/* Private / Static functions. */
static void _rshift_word(struct bn* a, int nwords)
{
  /* Naive method: */
  require(a, "a is null");
  require(nwords >= 0, "no negative shifts");

  int i;
  if (nwords >= BN_ARRAY_SIZE)
  {
    for (i = 0; i < BN_ARRAY_SIZE; ++i)
    {
      a->array[i] = 0;
    }
    return;
  }

  for (i = 0; i < BN_ARRAY_SIZE - nwords; ++i)
  {
    a->array[i] = a->array[i + nwords];
  }
  for (; i < BN_ARRAY_SIZE; ++i)
  {
    a->array[i] = 0;
  }
}


static void _lshift_word(struct bn* a, int nwords)
{
  require(a, "a is null");
  require(nwords >= 0, "no negative shifts");

  int i;
  /* Shift whole words */
  for (i = (BN_ARRAY_SIZE - 1); i >= nwords; --i)
  {
    a->array[i] = a->array[i - nwords];
  }
  /* Zero pad shifted words. */
  for (; i >= 0; --i)
  {
    a->array[i] = 0;
  }  
}


static void _lshift_one_bit(struct bn* a)
{
  require(a, "a is null");

  int i;
  for (i = (BN_ARRAY_SIZE - 1); i > 0; --i)
  {
    a->array[i] = (a->array[i] << 1) | (a->array[i - 1] >> ((8 * WORD_SIZE) - 1));
  }
  a->array[0] <<= 1;
}


static void _rshift_one_bit(struct bn* a)
{
  require(a, "a is null");

  int i;
  for (i = 0; i < (BN_ARRAY_SIZE - 1); ++i)
  {
    a->array[i] = (a->array[i] >> 1) | (a->array[i + 1] << ((8 * WORD_SIZE) - 1));
  }
  a->array[BN_ARRAY_SIZE - 1] >>= 1;
}


int main()
{
	int i = 0;
	char astring[2048];
	char *bstring = "3f5cc8956a812a1f";
	struct bn a;
	struct bn b;
	struct bn c;
	char buf[8192];
	scanf("%s", astring);
	bignum_init(&a);
	bignum_init(&b);
	bignum_init(&c);
	bignum_from_string(&a, astring,  strlen(astring));
	bignum_from_string(&b, bstring,  strlen(bstring));
	bignum_mul(&a, &b, &c);
	bignum_to_string(&c, buf, sizeof(buf));
	while (buf[i] != 0) {
		printf("%c", buf[i]);
		i += 1;
	}
	printf("\n");
	  
}
发愤图强想做全栈的小陈
关注
  • 16
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
密码学实验三 AES实验
03-20
包括实验报告和代码 （1） 深刻掌握AES算法的运行原理； （2） 编程实现AES算法加解密过程； （3） 掌握对称密码工作模式； （4） 编程实现支持多种工作模式和填充方式的DES加解密程序
应用密码学第二版主编刘嘉勇课件ppt
06-08
应用密码学第二版主编刘嘉勇课件ppt
应用密码学习题答案.zip
09-07
应用密码学习题答案（1-15）
哈工大密码学作业hw2-5
01-14
哈工大17级密码学作业，只有2-5，第一次作业没有电子版，可能在后续上传。本作业仅供参考。希望各位学弟学妹认真完成密码学作业，对密码学课程的知识点有很好的理解！
墨者学院-密码学加解密实训(摩斯密码第2题)
JimWu的博客
09-05 1062
密码学加解密实训(摩斯密码第2题) 难易程度:★★ 题目类型:代码审计 使用工具:FireFox浏览器、audacity 1.打开靶场，下载文件，这题没有加密文件格式，所以我们直接用音频编辑器audacity打开。 2.这题的难点在于它是在一段音乐中夹杂着摩斯密码，我试图把摩斯密码从音乐中分离出来，但没这能力。不过还是有两种方法得到答案。 一就是放大音频，我们就能清晰看到一长一短的摩斯密码。 ...
密码学中的SM2
ThePythonFucker的博客
06-21 1万+
SM2是中国密码学算法标准中的一种非对称加密算法，它是由国家密码管理局（中国密码局）发布的一种椭圆曲线公钥密码算法。SM2基于椭圆曲线离散对数问题，主要用于数字签名、密钥交换和加密等密码学应用。非对称加密：SM2使用非对称密钥加密体制，包括公钥和私钥。公钥用于加密数据和验证数字签名，私钥用于解密数据和生成数字签名。椭圆曲线密码学：SM2基于椭圆曲线密码学，通过椭圆曲线上的点运算来实现加密和解密操作。SM2采用的是素数域上的椭圆曲线，具体是由国家密码管理局指定的一条256位的椭圆曲线。安全性。
密码学基础知识总结
qq_41977843的博客
08-27 1万+
密码学、Diffiie-Hellam、DH、SHA1、SHA256、SM1、SM2、SM9、对称加密、非对称加密、分组加密、流密码
密码学基础
你好，明天，，的博客
11-05 4613
在介绍密码学之前，先说明一下密码学的作用。 信息系统的硬件系统安全和操作系统安全是信息系统安全的基础，密码和网络安全等技术是信息系统安全的关键技术。信息系统安全即信息安全，信息安全学科是综合计算机、通信、电子、数学、物理、生物、管理、法律和教育 等学科，并发展演绎而形成的交叉学科。 信息安全的理论基础： 1. 数学 ： 密码学——代数、数论、概率统计。 安全协议——逻辑学 信息对抗——博弈论 2. 信息论、控制论和系统论 3. 计算理论：可计算理论和计算复杂性理论 密码学：用基于数学方
浅谈密码学
热门推荐
想你依然心痛的博客
02-24 2万+
密码学作为一门研究信息安全的学科，扮演着保护我们数字化生活的重要角色。在当今信息时代，我们的个人和商业数据面临着越来越多的威胁，如黑客攻击、数据泄露等。而密码学的出现为我们提供了一种科学的方法，能够确保我们的信息在传输和存储过程中不被未授权的人访问和篡改。本文将简要介绍密码学的基本原理和应用领域，以及其在保护数字化生活中的重要性。通过了解密码学的基础知识，我们将能更好地保护个人隐私和敏感信息，建立一个安全可信的网络环境。密码学是研究编制密码和破译密码的技术科学。
密码学Cryptology
Abner's Technology Blog
01-23 2922
笔记修正记录】2022.1.23 密码学概述】密码体制分为对称和非对称。 密码学中的基本术语 明文:M 或 P，即plaintext 。 密文：C。加密算法：E 。 对称加密算法：SE。 对称解密算法：SD。解密算法：D 。 A的公钥：PKA 。 A的私钥：SKA。 对称密钥:K 。 密码体制:由明文空间SM、密文空间Sc、密钥空间SK、加密算法E和解密算法D构成的五元组{SM、Sc、SK、E、D}，称为密码体制。 密码系统（Cryptosystem）:用于加密和解密的系统。加密时，系统输
python密码学编程
02-16
python密码学入门。这个暂时全网没有免费版。我是从亚马逊购买的，现在分享给各位
现代密码学
weixin_44705017的博客
08-13 2032
密码学大纲目录引言Dan部分流密码分组密码体制公钥密码密码分配与密钥管理消息认证和哈希函数数字签名和认证协议密码协议可证明安全网络加密与认证 大纲 目录 引言 Dan部分 流密码 分组密码体制 公钥密码 密码分配与密钥管理 消息认证和哈希函数 数字签名和认证协议 密码协议 可证明安全 网络加密与认证 ...
现代密码学复习
qq_52504945的博客
03-02 1万+
现代密码学知识大汇总
安全防御——密码学
金色%夕阳的博客
09-16 3561
密码—明文–>算法+密钥—>密文 对称加密算法解决信息的安全传输通道 非对称加密算法解决对称加密算法密钥的安全传输通道 对称加密——速度快但是密钥不安全 非对称加密——速度慢但是密钥安全 机密性问题最佳解决方案:用非对称加密算法加密对称加密算法的密钥 完整性与身份认证问题最佳解决方案:对明文a进行hash运算得到定长值h，然后对h进行非对称运算用私钥加密得到值k，然后对明文a进行对称运算得到y，传输时同时传输y和k，收到后用非对称公钥解开k得到h，然后用对称算法解开y得到a，然后对a进行hash得到h”如果
密码学的学习心得
shaoNianABin123的博客
11-07 1万+
学习了网络安全的课程后感触很深，尤其对密码学。密码学充满了神秘性，让我对它产生了浓厚的兴趣和好奇。这个学期以来，学习到了很多东西，学到了各种密码体制，让我知道了密码体制在我们的生活中发挥着巨大的作用。密码学一直保护着我们信息的安全。黑客盗取密码保护的信息以获取利益，而密码学家不断地去评估密码算法的安全性，找到其漏洞，以设计出更安全的密码算法。 密码学是主要研究通信安全和保密的学科，密码编码学主要研究对信息进行变换，以保护信息在传递过程中不被敌方窃取、解读和利用的方法。密码学可以...
(python)cryptography-安全的加密
marst437730201的博客
05-14 786
前言是一个广泛使用的 Python 加密库，提供了各种加密、哈希和签名算法的实现。它支持多种加密算法，如 AES、RSA、ECC 等，以及哈希函数（如 SHA-256、SHA-384 等）和数字签名算法（如 DSA、ECDSA 等）.
黑客技术需要学什么？黑客技术哪里可以学？
2401_84205765的博客
05-14 641
掌握黑客技术：你需要学习什么？在当今的数字世界中，你可能会听到“黑客”一词，这通常与犯罪行为和不道德的活动联系在一起。然而，你可能没有意识到的是，"黑客"也可以是指那些精通计算机系统、网络和技术的人，他们被称为“白帽黑客”或“道德黑客”。这些专业人士帮助保护我们的在线安全，而不是破坏它。如果你对成为这样的网络安全专家感兴趣，那么你需要学习什么呢？基本计算机科学 :这是所有与计算机技术相关的领域的基础。从数据结构和算法到操作系统和计算机网络，理解计算机科学的基础知识将有助于你更好地理解更复杂的技术领域。
链接表存储图(C++注释详解): 构建表 & 深度优先遍历 (DFS)
H13420972436的博客
05-15 420
代码实现: 构建表 & 深度优先遍历 (DFS)
质数和约数
最新发布
2302_77099705的博客
05-21 759
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
密码学引论 第二版 csdn
09-10
《密码学引论》第二版是一本经典的密码学教材，深入介绍了密码学的基本原理和技术。该书由知名密码学家Bruce Schneier所著，旨在帮助读者全面了解密码学的概念、原理和应用。 首先，该书在密码学的基本概念方面进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

发愤图强想做全栈的小陈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值