C／C++实现区块链（下）之区块链实现（原创代码，转载必究）

资讯 2024-07-09 阅读:157 评论:0

美化布局示例

欧易(OKX)最新版本

【遇到注册下载问题请加文章最下面的客服微信】永久享受返佣20%手续费！

APP下载全球官网大陆官网

币安(Binance)最新版本

币安交易所app【遇到注册下载问题请加文章最下面的客服微信】永久享受返佣20%手续费！

APP下载官网地址

火币HTX最新版本

火币老牌交易所【遇到注册下载问题请加文章最下面的客服微信】永久享受返佣20%手续费！

APP下载官网地址

#include <iostream>
#include <stdio.h>
#include <windows.h>
#include <string>
#include <cmath>
#include <climits>
#include <list>
#include <time.h>
using namespace std;

struct Moving_Point {
  unsigned long long x;
  unsigned long long y;
};

int circle=1;

class Martix {
public:
  static const int circle_s=1;              //假定向量环路为1;
  static const int KEY=Martix::circle_s * 8;
private:
  unsigned long long martix_4_2[Martix::KEY / 2][2];        //存储向量矩阵
  unsigned long long martix_8_8[Martix::KEY][Martix::KEY];    //存储由向量矩阵得到的转置矩阵
  unsigned long long martix_complete[KEY * 2];        //存储操作完成后的矩阵（一维）

public:
  Martix(string a) {};
  Martix(int a, int b,int circle)
  {
    int key=8;
    int cir=circle;
    while (cir--)
    {
      martix_4_2[key / 2 - 4][0]=(-1)*b;  martix_4_2[key / 2 - 4][1]=(-1)*a;
      martix_4_2[key / 2 - 3][0]=b;     martix_4_2[key / 2 - 3][1]=(-1)*a;
      martix_4_2[key / 2 - 2][0]=b;     martix_4_2[key / 2 - 2][1]=a;
      martix_4_2[key / 2 - 1][0]=(-1)*b;  martix_4_2[key / 2 - 1][1]=a;
      key +=8;
    }
  }

  void Change_New_Martix() {
    for (int i=0; i < 2; i++)
    {
      for (int j=0; j < 2; j++)
      {
        martix_8_8[i][j]=0;
      }
    }

    for (int j=2; j < KEY / 2 + 2; j++) {
      martix_8_8[0][j]=martix_4_2[j - 2][0] * (-1);
      martix_8_8[1][j]=martix_4_2[j - 2][1] * (-1);
    }

    for (int i=2; i < KEY / 2 + 2; i++) {
      martix_8_8[i][0]=martix_4_2[i - 2][0] * (-1);
      martix_8_8[i][1]=martix_4_2[i - 2][1] * (-1);
    }

    for (int i=2; i < KEY / 2 + 2; i++)
    {
      for (int j=2; j < KEY / 2 + 2; j++)
      {
        martix_8_8[i][j]=0;
      }
    }
  }

public:
  void Save_Martix()
  {
    int key=0;
    for (int i=0; i < KEY / 2 + 2; i++)
    {
      for (int j=0; j < KEY / 2 + 2; j++)
      {
        if (martix_8_8[i][j] !=0)
        {
          martix_complete[key++]=martix_8_8[i][j];
        }
      }
    }
  }

  unsigned long long GetPublicKey()
  {
    unsigned long long public_key=martix_complete[0];
    for (int i=1; i < KEY * 2; i++)
    {
      if (i % 2==0)
      {
        public_key=public_key + martix_complete[i];
      }
      else {
        public_key=public_key * martix_complete[i];
      }
    }
    return public_key;
  }
};

class Cryptography :Martix
{
public:
  
  unsigned long long a;         //椭圆长轴的半轴长度
  unsigned long long b;         //椭圆短轴的半轴长度

                  
  unsigned long long public_Key;      //通过椭圆矩阵算法得到的公钥G
  Moving_Point p;         //随机选定的在椭圆上的点

public:
  Cryptography(string a) :Martix("OK") {};
  Cryptography(unsigned long long in_a, unsigned long long in_b,int diffcult) :Martix(in_a, in_b,diffcult)
  {
    this->a=in_a;
    this->b=in_b;
    p.x=0;
    p.y=0;
    public_Key=Getpublickey();
  }

  unsigned long long Getpublickey()
  {
    Get_Public_Key();
    return public_Key;
  }

  Moving_Point GetPoint()
  {
    Get_Point();
    return p;
  }
public:
  void PrintPrivateKey() {
    cout << "#############私钥:#############" << endl;
    cout << "长轴：" << 2*this->a << "		";
    cout << "短轴：" << 2*this->b << endl;
  }
private:
  void Get_Point()
  {
    if (p.x==0 && p.y==0)
    {
      while (!Is_Moving_Point())
      {
        Get_Moving_Point_P();
      }
    }
  }

  void Get_Public_Key()
  {
    this->Change_New_Martix();
    this->Save_Martix();
    this->public_Key=this->GetPublicKey();
  }

  void Get_Moving_Point_P() //得到一个随机的在椭圆上的点的坐标
  {
    for (int i=0; i < this->a; i++)
    {
      for (int j=0; j < this->b; j++)
      {
        p.x=i;
        p.y=j;
      }
    }
  }

  bool Is_Moving_Point() {
    if (pow(b, 2)*pow(p.y, 2) + pow(a, 2)*pow(p.x, 2)==pow(a, 2)*pow(b, 2) && p.y <=a && p.x <=b)
      return true;
    else
      return false;
  }
};

struct block {
  unsigned long long this_hash;
  unsigned long long pre_hash;
  unsigned long long data;
};

block blo;
block pre_blo={0,0,0};
class Create_Block:public Cryptography {
public:
  list<block> Block;
public:
  Create_Block(string a):Cryptography("OK") {};
  Create_Block(int x=rand()*2, int y=rand(), int diffcult=1):Cryptography(x,y,diffcult){
  }
  void Make_First_Block()
  {
    Getpublickey();
    blo.data=circle;
    blo.pre_hash=0;
    blo.this_hash=(blo.pre_hash+public_Key) * (a+b);
    Block.push_back(blo);
  }
  void Append_Block()
  {
    pre_blo=blo;
    bool flag=true;
    auto temp=public_Key; 
    circle=circle + 1;
    Getpublickey();
    blo.data=circle;
    blo.pre_hash=blo.this_hash;
    blo.this_hash=(blo.pre_hash + public_Key) * (a + b);
    for(list<block>::iterator itor=Block.begin(); itor !=Block.end(); itor++)
    {
      if ((*itor).this_hash !=(*itor).pre_hash + temp * (a + b))
      {
        flag=false;
        break;
      }
    }
    if (flag) { Block.push_back(blo); };
  }
};

class Get_Block :Create_Block {
public:
  int diffcult;
  int number=1;
  Get_Block():Create_Block("OK"){
  }
  void  calc()
  {
    double start=clock();
    while (true){
      for (unsigned long long  z=1; z < ULLONG_MAX; z++){
        for (unsigned long long  j=1; j < 65535; j=j + 1) {
          for (unsigned long long i=1; i < 65535; i=i + 1) {
            Cryptography *person=new Cryptography(i,j,z);
            person->Getpublickey();
            block bloc;
            bloc.data=circle;
            bloc.pre_hash=pre_blo.this_hash;
            bloc.this_hash=(blo.pre_hash + person->public_Key) * (i + j);
            if (blo.data==bloc.data &&blo.pre_hash==bloc.pre_hash && blo.this_hash==bloc.this_hash)
            {
              double end=clock();
              cout << "历时"<<end-start<<"毫秒获得的第" << number++ <<"个区块信息为：" << endl;
              cout << "data:" << bloc.data << endl;
              cout << "this_hash:" << bloc.this_hash << endl;
              cout << "pre_hash:" << bloc.pre_hash << endl << "=======================" << endl << endl;
              this->Append_Block();
              start=clock();
            }
            delete []person;
          }
        }
      }
    }
  }
};

int main()
{
  Create_Block * one=new Create_Block();
  one->Make_First_Block();
  Get_Block* two=new Get_Block();
  two->calc();
  return 0;
}