一个ECC加密算法的使用范例

import * as eccryptoJS from 'eccrypto-js'

//加解密函数的参数都是buffer类



//Alice

//一个新的随机的32字节私钥，私钥对应的未压缩（65字节）公钥。

const keyPairA = eccryptoJS.generateKeyPair();

console.info("privateKey:", keyPairA.privateKey);

console.info("publicKey:", keyPairA.publicKey);

//send publicKey to Bob



//Bob

//随机生成AES的密钥

const AESKey = eccryptoJS.randomBytes(32);

console.info("AESKey:", AESKey);

const iv = eccryptoJS.randomBytes(16);



//用ECC加密AES密钥

const EncryptedAESKey = await eccryptoJS.encrypt(keyPairA.publicKey, AESKey);

console.info("EncryptedAESKey:", EncryptedAESKey);



//待发送的明文str，先转成buffer格式

const str = 'test message to encrypt';

const msg = eccryptoJS.utf8ToBuffer(str);



//用未加密的AES密钥加密明文

const ciphertext = await eccryptoJS.aesCbcEncrypt(iv, AESKey, msg);

console.info("ciphertext:", ciphertext);

//send 密文encrypt_str and AESKeyEncrypt to Alice，iv？



//Alice

//用私钥解密加密后的AES密钥

const DecryptedAESKey = await eccryptoJS.decrypt(keyPairA.privateKey, EncryptedAESKey);

console.info("decryptedAESKey:", DecryptedAESKey);

//用AES密钥解密明文

const decrypted = await eccryptoJS.aesCbcDecrypt(iv, DecryptedAESKey, ciphertext);

console.info("decrypted:", decrypted.toString());

    package main

    

    import (

        "fmt"

        "crypto/ecdsa"

        "crypto/elliptic"

        "crypto/rand"

        "crypto/sha256"

        "math/big"

    )

    

    func main() {

        //明文 

        message := []byte("Hello world")

        

        key, err := NewSigningKey()

        if err != nil {

            return

        }

    

        signature, err := Sign(message, key)

    

        fmt.Printf("签名后：%x\n", signature)

        if err != nil {

            return

        }

    

        if !Verify(message, signature, &key.PublicKey) {

            fmt.Println("验证失败！")

            return

        }else{

            fmt.Println("验证成功！")

        }

    }

    

    func NewSigningKey() (*ecdsa.PrivateKey, error) {

        key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

        return key, err

    }

    

    // Sign signs arbitrary data using ECDSA.

    func Sign(data []byte, privkey *ecdsa.PrivateKey) ([]byte, error) {

        // hash message

        digest := sha256.Sum256(data)

    

        // sign the hash

        r, s, err := ecdsa.Sign(rand.Reader, privkey, digest[:])

        if err != nil {

            return nil, err

        }

    

        // encode the signature {R, S}

        // big.Int.Bytes() will need padding in the case of leading zero bytes

        params := privkey.Curve.Params()

        curveOrderByteSize := params.P.BitLen() / 8

        rBytes, sBytes := r.Bytes(), s.Bytes()

        signature := make([]byte, curveOrderByteSize*2)

        copy(signature[curveOrderByteSize-len(rBytes):], rBytes)

        copy(signature[curveOrderByteSize*2-len(sBytes):], sBytes)

    

        return signature, nil

    }

    

    // Verify checks a raw ECDSA signature.

    // Returns true if it's valid and false if not.

    func Verify(data, signature []byte, pubkey *ecdsa.PublicKey) bool {

        // hash message

        digest := sha256.Sum256(data)

    

        curveOrderByteSize := pubkey.Curve.Params().P.BitLen() / 8

    

        r, s := new(big.Int), new(big.Int)

        r.SetBytes(signature[:curveOrderByteSize])

        s.SetBytes(signature[curveOrderByteSize:])

    

        return ecdsa.Verify(pubkey, digest[:], r, s)

    }

/* Copyright 2014, Kenneth MacKay. Licensed under the BSD 2-clause license. */



#include "uECC.h"



#include <stdio.h>

#include <string.h>

#include <n32g45x_rng.h>

#include <sys/time.h>



uint64_t getTimeMs()

{

    struct timeval tv;

    gettimeofday(&tv, NULL);

    return tv.tv_sec * 1000 + tv.tv_usec / 1000;

}





void vli_print(uint8_t *vli, unsigned int size) {

    for(unsigned i=0; i<size; ++i) {

        printf("%02X ", (unsigned)vli[i]);

    }

}



int ecc_rng(uint8_t *dest,unsigned size)

{

        return (int)GetTrueRand_U32((uint32_t *)dest, size/4);

}



int TestEcdh() {

    int i, c;

    uint8_t private1[32] = {0};

    uint8_t private2[32] = {0};

    uint8_t public1[64] = {0};

    uint8_t public2[64] = {0};

    uint8_t secret1[32] = {0};

    uint8_t secret2[32] = {0};

        uECC_set_rng(ecc_rng);

    

    const struct uECC_Curve_t * curves[5];

    int num_curves = 0;

#if uECC_SUPPORTS_secp160r1

    curves[num_curves++] = uECC_secp160r1();

#endif

#if uECC_SUPPORTS_secp192r1

    curves[num_curves++] = uECC_secp192r1();

#endif

#if uECC_SUPPORTS_secp224r1

    curves[num_curves++] = uECC_secp224r1();

#endif

#if uECC_SUPPORTS_secp256r1

    curves[num_curves++] = uECC_secp256r1();

#endif

#if uECC_SUPPORTS_secp256k1

    curves[num_curves++] = uECC_secp256k1();

#endif

    

    printf("Testing 256 random private key pairs\n");



    for (c = 0; c < num_curves; ++c) {

        for (i = 0; i < 256; ++i) {

            printf(".");

            fflush(stdout);

                        getTimeMs();

            if (!uECC_make_key(public1, private1, curves[c]) ||

                !uECC_make_key(public2, private2, curves[c])) {

                printf("uECC_make_key() failed\n");

                return 1;

            }

                        getTimeMs();



                        printf("1===============\n\n");



            if (!uECC_shared_secret(public2, private1, secret1, curves[c])) {

                printf("shared_secret() failed (1)\n");

                return 1;

            }

                        getTimeMs();

            if (!uECC_shared_secret(public1, private2, secret2, curves[c])) {

                printf("shared_secret() failed (2)\n");

                return 1;

            }

                getTimeMs();

                        printf("2===============\n\n");

            if (memcmp(secret1, secret2, sizeof(secret1)) != 0) {

                printf("Shared secrets are not identical!\n");

                printf("Private key 1 = ");

                vli_print(private1, 32);

                printf("\n");

                printf("Private key 2 = ");

                vli_print(private2, 32);

                printf("\n");

                printf("Public key 1 = ");

                vli_print(public1, 64);

                printf("\n");

                printf("Public key 2 = ");

                vli_print(public2, 64);

                printf("\n");

                printf("Shared secret 1 = ");

                vli_print(secret1, 32);

                printf("\n");

                printf("Shared secret 2 = ");

                vli_print(secret2, 32);

                printf("\n");

            }

        }

        printf("\n");

    }

    

    return 0;

}

/* Copyright 2014, Kenneth MacKay. Licensed under the BSD 2-clause license. */



#include "uECC.h"



#include <stdio.h>

#include <string.h>



int ecc_rng(uint8_t *dest,unsigned size);

int TestEcdsa() {

    int i, c;

    uint8_t private[32] = {0};

    uint8_t public[64] = {0};

    uint8_t hash[32] = {0};

    uint8_t sig[64] = {0};

        //unsigned char *plat_public = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEFBfm3uQdpKNVVLWO1OQlvC/LEdBG6V68//nzEmeQnL83xWJPs16HBLvxsax2rRICQTTkf4F9fyLG4bjSoYBpkg==";

        //unsigned char *plat_hash[32] = {0};

        //unsigned char *plat_sig = "MEQCIEEgzmiGBWHLYJ1hg0cKi4KCAUX6MLDfHIMfmPlAwSsOAiA4tKnLfab+wVr8M1KEpsCCoDN89mKorzzxez9IZenqpg==";

        uECC_set_rng(ecc_rng);

        uECC_Curve _secp256r1 = uECC_secp256r1();

        uECC_Curve _secp256k1 = uECC_secp256k1();

        uint8_t beigu_public[64] = {

        0x85, 0xC2, 0xDD, 0x2D, 0x2E, 0x52, 0x18, 0x35, 0x9B, 0xA1, 0xDD, 0x25, 0xB3, 0x6F, 0x02, 0xF4, 0xD7, 0x7C, 0x25, 0xF9, 0xD7, 0x4F, 0x49, 0x3C, 0x41, 0x76, 0xCE, 0x08, 0x19, 0x91, 0xCF, 0x0F, 0x7B, 0x2E, 0x28, 0xD0, 0x0E, 0x55, 0x69, 0xAE, 0xC1, 0x11, 0x47, 0x3D, 0xB8, 0x8F, 0x0D, 0x76, 0xE9, 0xF9, 0x65, 0x8C, 0x4A, 0x83, 0x0D, 0xF5, 0xAE, 0x78, 0x69, 0xB4, 0x8D, 0x96, 0x5B, 0x64

        };

        uint8_t beigu_hash[32] = {0x76, 0x29, 0x4f, 0x8e, 0xc5, 0x36, 0xed, 0x41, 0x8f, 0x12, 0x26, 0x0e, 0xea, 0xb3, 0x5f, 0xa5, 0xf9, 0x0a, 0xb5, 0xc3, 0xec, 0xdd, 0xbd, 0xd6, 0x51, 0x57, 0xa9, 0x60, 0xd0, 0x2f, 0xe8, 0x61};

        uint8_t beigu_sig[64] = {0x4F, 0xC8, 0x14, 0xA7, 0x23, 0x47, 0x6C, 0xBC, 0x22, 0x13, 0xE5, 0xB2, 0x92, 0x32, 0xA1, 0x01, 0x71, 0xEB, 0x8B, 0x99, 0x67, 0x93, 0xD7, 0xC2, 0xBC, 0x52, 0x1B, 0xA2, 0xF6, 0x86, 0x34, 0x87, 0x62, 0xA5, 0xCF, 0xC7, 0x6B, 0xF6, 0xF1, 0x48, 0x28, 0x48, 0x02, 0xC2, 0x60, 0x60, 0xF8, 0xDE, 0x9F, 0xD8, 0x4C, 0xDA, 0xF2, 0xE5, 0x52, 0x6A, 0xCF, 0x49, 0x2B, 0xDA, 0x9C, 0xF4, 0x41, 0xD5};



        //memcpy(beigu_hash, beigu_public, sizeof(beigu_hash));



        if (!uECC_verify(beigu_public, beigu_hash, sizeof(beigu_hash), beigu_sig, _secp256r1)) {

       printf("=====1 beigu uECC_verify() failed\n");

        }



        if (!uECC_verify(beigu_public, beigu_hash, sizeof(beigu_hash), beigu_sig, _secp256k1)) {

       printf("=====2 beigu uECC_verify() failed\n");

        }



    const struct uECC_Curve_t * curves[5];

    int num_curves = 0;

#if uECC_SUPPORTS_secp160r1

    curves[num_curves++] = uECC_secp160r1();

#endif

#if uECC_SUPPORTS_secp192r1

    curves[num_curves++] = uECC_secp192r1();

#endif

#if uECC_SUPPORTS_secp224r1

    curves[num_curves++] = uECC_secp224r1();

#endif

#if uECC_SUPPORTS_secp256r1

    curves[num_curves++] = uECC_secp256r1();

#endif

#if uECC_SUPPORTS_secp256k1

    curves[num_curves++] = uECC_secp256k1();

#endif

    

    printf("Testing 256 signatures\n");

    for (c = 0; c < num_curves; ++c) {

        for (i = 0; i < 256; ++i) {

            printf(".");

            fflush(stdout);



            if (!uECC_make_key(public, private, curves[c])) {

                printf("uECC_make_key() failed\n");

                return 1;

            }

            memcpy(hash, public, sizeof(hash));

            

            if (!uECC_sign(private, hash, sizeof(hash), sig, curves[c])) {

                printf("uECC_sign() failed\n");

                return 1;

            }



            if (!uECC_verify(public, hash, sizeof(hash), sig, curves[c])) {

                printf("uECC_verify() failed\n");

                return 1;

            }

        }

        printf("\n");

    }

    

    return 0;

}