精华内容
下载资源
问答
  • AES加密 基于openssl前序环境环境准备关闭防火墙禁用SELINUXk8s网络配置文件关于ipvs的转换SWAP安装kubeadm和kubelet镜像准备master节点初始化 前序 AES介绍 Kubernetes是一门基于go语言开发的容器编排的技术。容器...

    前序

    AES介绍
    不多说了,可以度娘。。。
    贴点传送门,都是优秀的参考文献
    链接:https://blog.csdn.net/weixin_45303938/article/details/108089078
    实用贴——分组加密的常用工作模式
    链接:https://blog.csdn.net/duanxingheng/article/details/11730617
    OPENSSL库的使用-AES篇

    实用函数

    贴一下头文件,有兴趣的都应该去翻openssl/include
    #include <openssl/aes.h> //aes加密

    # define AES_ENCRYPT     1
    # define AES_DECRYPT     0
    
    /*
    * Because array size can't be a const in C, the following two are macros.
    * Both sizes are in bytes.
    */
    
    # define AES_MAXNR 14
    # define AES_BLOCK_SIZE 16
    //	AES默认块长 128bits,大部分代码会调用  AES_BLOCK_SIZE  去初始化
    
    typedef struct aes_key_st AES_KEY;
    
    const char *AES_options(void);
    
    int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
                          AES_KEY *key);
    int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
                          AES_KEY *key);
    /*
    这两个函数分别用于加解密的密钥生成
    @const unsigned char *userKey    约定密码
    @const int bits					密码长度  分别对应128 、 192 、 256   
      		注意这里是bits,所以是输入密码长度*8,也就是16位长度密码对应128bits
    @AES_KEY *key				    生成密体
    */
    
    
    void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,
                       const AES_KEY *key, const int enc);
    void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
                       size_t length, const AES_KEY *key,
                       unsigned char *ivec, const int enc);
    
    /*
    这两个函数分别用于加解密的密钥生成
    @in              需要加密/解密的数据
    @out            计算后输出的数据
    @length 		数据长度
    @key 			密钥体AES_KEY 
    @ivec   		初始向量(一般为16字节全0)
    @enc   			AES_ENCRYPT 代表加密, AES_DECRYPT代表解密;
    */
    
    

    C++代码

    可以使用#include <openssl/aes.h> 去进行加密处理

    // AES加密
    std::string aes_encode(std::string& data, std::string& passwd)
    {
    
      
      int dataLen = data.length();
      int nPadd = AES_BLOCK_SIZE - dataLen % AES_BLOCK_SIZE;    //pkcs7padding,缺N位就补N个N
      data.append(size_t(nPadd), char(nPadd));
    
      dataLen = data.length();                                 //补齐之后的数据长度
      unsigned char ivb[AES_BLOCK_SIZE];           			   //一般16位,关于IV这里用的是全‘0’填充
      memset(&ivb, '0', AES_BLOCK_SIZE);		//有兴趣增加密码安全的可以置换或者随机IV随加密结果输出
      unsigned char buf[dataLen];
      memset(&buf, 0, dataLen);
    
      AES_KEY key;
      AES_set_encrypt_key((unsigned const char *)(passwd.c_str()), 128, &key);       //*8 int bit 设置密钥
    
      AES_cbc_encrypt((unsigned const char *)(data.c_str()), buf, dataLen, &key, &(ivb[0]), AES_ENCRYPT); 
      //enc: 加密/解密模式,AES_ENCRYPT,加密;AES_DECRYPT,解密;
    
      auto base64Out = base64_encode(buf, dataLen);				//这个不是加密过程,普通base64
    
      
      return base64Out;
    }
    
    std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
      std::string ret;
      int i = 0;
      int j = 0;
      unsigned char char_array_3[3];
      unsigned char char_array_4[4];
      
      while (in_len--) {
          char_array_3[i++] = *(bytes_to_encode++);
          if (i == 3) {
              char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
              char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
              char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
              char_array_4[3] = char_array_3[2] & 0x3f;
              
              for(i = 0; (i <4) ; i++)
                  ret += base64_chars[char_array_4[i]];
              i = 0;
          }
      }
      
      if (i)
      {
          for(j = i; j < 3; j++)
              char_array_3[j] = '\0';
          
          char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
          char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
          char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
          char_array_4[3] = char_array_3[2] & 0x3f;
          
          for (j = 0; (j < i + 1); j++)
              ret += base64_chars[char_array_4[j]];
          
          while((i++ < 3))
              ret += '=';
          
      }
      
      return ret;
      
    }
    

    openssl-EVP加密框架

    好吧,等我试了几次死磕出了加密方法之后,小伙伴突然说openssl有个EVP框架,实现了加解密过程。。。早说嘛,不过说实话实际用上之后觉得好像比自己写还复杂,可能对于ECB和CBC模式来说大材小用了,期望RSA会简单还有流式加解密模式。

    #include <openssl/evp.h>

    std::string aes_encodeV1(std::string& data, std::string& passwd)
    {
      EVP_CIPHER_CTX *ctx;
      int outlen = 0;
      int encLen = 0;
      ctx = EVP_CIPHER_CTX_new();
      int dataLen = data.length();
    
      int nPadd = AES_BLOCK_SIZE - dataLen % AES_BLOCK_SIZE;    //pkcs7padding
      data.append(size_t(nPadd), char(nPadd));
      dataLen = data.length();
      unsigned char ivb[AES_BLOCK_SIZE];
      memset(&ivb, '0', AES_BLOCK_SIZE);
      unsigned char buf[dataLen];
      memset(&buf, 0, dataLen);
    
      EVP_CipherInit_ex(ctx, EVP_aes_128_cbc(), NULL, (unsigned const char *)(passwd.c_str()), ivb, 1);
      EVP_CipherUpdate(ctx, buf, &outlen, (unsigned const char *)(data.c_str()), dataLen);
      encLen = outlen;
      EVP_CipherFinal(ctx, buf+outlen, &outlen);
      encLen += outlen;
      EVP_CIPHER_CTX_free(ctx);
    
      auto base64Out = base64_encode(buf, encLen);	
      return base64Out;
    }
    

    python验证代码

    #!/usr/bin/env python3
    #
    # This is a simple script to encrypt a message using AES
    # with CBC mode in Python 3.
    # Before running it, you must install pycryptodome:
    #
    # $ python -m pip install PyCryptodome
    #
    # Author.: silverzzq
    # Date...: 2021-03-25
    ##
    from base64 import b64decode
    
    from Crypto.Cipher import AES
    from Crypto.Util.Padding import pad, unpad
    
    class AESCipher:
        def __init__(self, key):
            self.key = key.encode('utf8')
    
        def encrypt(self, data):
            iv = ""
            iv = iv.ljust(16,'0').encode('utf-8')
            self.cipher = AES.new(self.key, AES.MODE_CBC, iv)
            return b64encode(self.cipher.encrypt(pad(data.encode('utf-8'), 
                AES.block_size)))
            #pad中默认的padding模式就是pkcs7padding
    
    
    if __name__ == '__main__':
        msg = "12345678123456781234567812345678"
        pwd = "1234567812345678"
        print('Ciphertext:', AESCipher(pwd).encrypt(msg).decode('utf-8'))
    
    展开全文
  • AES加密openssl使用(2)

    千次阅读 2012-12-03 22:14:52
    书接上篇《AES加密openssl安装》,在文章结尾简单列出了openssl接口使用,但是峰回路转旧的代码总是满足不了新的需求。我想将加密后的二进制数手动输入然后通过算法解密,怎么办,。。。。?使用base64啊。加密后...

           书接上篇《AES加密只openssl安装》,在文章结尾简单列出了openssl接口使用,但是峰回路转旧的代码总是满足不了新的需求。我想将加密后的二进制数手动输入然后通过算法解密,怎么办,。。。。?使用base64啊。加密后的结果因为是二进制数字,而base64编码之中要求传入编码的长度,于是使用strlen就不怎么靠谱了,加密后的长度怎么求出。解决1.使用MD5加密为固定长度,缺点不可逆。2.memset为255(空格)吧

            且看代码:

    linux版本suse下编译通过

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <openssl/aes.h>
    #include <openssl/pem.h>
    #include <openssl/bio.h>
    #include <openssl/evp.h>
    
    
    void Base64Encode(unsigned char *inputString, int inLen, unsigned char *outputString, int *outLen)
    {    
        BIO *bmem = NULL;
        BIO *b64 = NULL;
        BUF_MEM *bptr = NULL;
        if ((NULL == inputString) ||
            (NULL == outputString))
        {
            return;
        }  
    
        b64 = BIO_new(BIO_f_base64());
        bmem = BIO_new(BIO_s_mem());
        b64 = BIO_push(b64, bmem);
        
        BIO_write(b64, inputString, inLen);
        BIO_flush(b64);
        BIO_get_mem_ptr(b64, &bptr);
        if (bptr->length > *outLen)
        {
            *outLen = bptr->length;
            return;
        }
        
        memcpy(outputString, bptr->data, bptr->length-1);
        outputString[bptr->length-1] = 0;
        *outLen = bptr->length-1;
        BIO_free_all(b64);
        return;
    }
    void Base64Decode(const char* inputString, int inLen, unsigned char* outputString, int  *outLen)
    {
        BIO * b642 = NULL;
        BIO * bmem2 = NULL;
        char tmp[inLen + 1];
        if(NULL == inputString || NULL == outputString)
        {
            return;
        }
        
        tmp[inLen] = '\n';      /*Openssl demand to have '\n' to end the string.*/
        memcpy(&tmp[0], inputString, inLen);
        memset(outputString, 0 , *outLen);
        
        b642 = BIO_new(BIO_f_base64());
        bmem2 = BIO_new_mem_buf(&tmp[0], inLen+1);
        bmem2 = BIO_push(b642, bmem2);
        *outLen = BIO_read(bmem2, outputString, *outLen);
        BIO_free_all(bmem2);
        return ;
    }
    
    void aes_box_encrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
        memcpy(key,"1234567890123456",AES_BLOCK_SIZE);
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_encrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string)+1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_ENCRYPT);
    
    }
    void aes_box_decrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
         memcpy(key,"1234567890123456",AES_BLOCK_SIZE);
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_decrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string)+1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_DECRYPT);
    }
    int main(int argc,char *argv[]) 
    {
        unsigned char ucIsEncrypt = 3;  
        unsigned char sourceStringTemp[100];
        unsigned char dstStringTemp[100];
        unsigned char printString[100];
        unsigned long ulBase64SrcLen = 0;
        unsigned long ulBase64DstLen = 100;
    
        memset(sourceStringTemp, 0 ,100);
        memset(dstStringTemp, 0 ,100);
        memset(printString, 0, 100);
        
        
        strcpy((char*)sourceStringTemp, argv[1]);
        ucIsEncrypt = atoi(argv[2]);
    
        if(AES_ENCRYPT == ucIsEncrypt)
        {
            aes_box_encrypt(sourceStringTemp,dstStringTemp);
           
            ulBase64SrcLen = strlen(dstStringTemp);        
            Base64Encode(dstStringTemp, ulBase64SrcLen , printString, &ulBase64DstLen);
            printf("%s\r\n", printString);
               
        }
        else if(AES_DECRYPT == ucIsEncrypt)
        {        
            ulBase64SrcLen = strlen(sourceStringTemp);        
            Base64Decode(sourceStringTemp, ulBase64SrcLen, printString, &ulBase64DstLen);        
            aes_box_decrypt(printString,dstStringTemp);
    
            printf("%s\r\n", dstStringTemp);
        }    
    
        return 0;
    }
    
    

    关于带参数main函数使用问题: 

    gcc AESPassword.c -o AESPassword

    ./AESPassword icd 1

    window下VS2008编译通过

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "openssl/aes.h"
    
    #include "openssl/pem.h"
    #include "openssl/bio.h"
    #include "openssl/evp.h"
    #pragma comment(lib, "4758cca.lib")
    #pragma comment(lib, "aep.lib")
    #pragma comment(lib, "atalla.lib")
    #pragma comment(lib, "4758cca.lib")
    #pragma comment(lib, "chil.lib")
    #pragma comment(lib, "capi.lib")
    #pragma comment(lib, "cswift.lib")
    #pragma comment(lib, "gmp.lib")
    #pragma comment(lib, "libeay32.lib")
    #pragma comment(lib, "nuron.lib")
    #pragma comment(lib, "padlock.lib")
    #pragma comment(lib, "ssleay32.lib")
    #pragma comment(lib, "gost.lib")
    #pragma comment(lib, "sureware.lib")
    #pragma comment(lib, "ubsec.lib")
    
    
    void Base64Encode(unsigned char *inputString, int inLen, unsigned char *outputString, int *outLen)
    {    
    	BIO *bmem = NULL;
    	BIO *b64 = NULL;
    	BUF_MEM *bptr = NULL;
    	if ((NULL == inputString) ||
    		(NULL == outputString))
    	{
    		return;
    	}  
    
    	b64 = BIO_new(BIO_f_base64());
    	bmem = BIO_new(BIO_s_mem());
    	b64 = BIO_push(b64, bmem);
    
    	BIO_write(b64, inputString, inLen);
    	BIO_flush(b64);
    	BIO_get_mem_ptr(b64, &bptr);
    	if (bptr->length > *outLen)
    	{
    		*outLen = bptr->length;
    		return;
    	}
    
    	memcpy(outputString, bptr->data, bptr->length-1);
    	outputString[bptr->length-1] = 0;
    	*outLen = bptr->length-1;
    	BIO_free_all(b64);
    	return;
    }
    void Base64Decode(const char* inputString, int inLen, unsigned char* outputString, int  *outLen)
    {
    	BIO * b642 = NULL;
    	BIO * bmem2 = NULL;
    	char tmp[50 + 1];
    	if(NULL == inputString || NULL == outputString)
    	{
    		return;
    	}
    
    	tmp[inLen] = '\n';      /*Openssl demand to have '\n' to end the string.*/
    	memcpy(&tmp[0], inputString, inLen);
    	memset(outputString, 0 , *outLen);
    
    	b642 = BIO_new(BIO_f_base64());
    	bmem2 = BIO_new_mem_buf(&tmp[0], inLen+1);
    	bmem2 = BIO_push(b642, bmem2);
    	*outLen = BIO_read(bmem2, outputString, *outLen);
    	BIO_free_all(bmem2);
    	return ;
    }
    
    void aes_box_encrypt(unsigned char* source_string, unsigned char* des_string)
    {
    	int iLoop = 0;
    	int iLen =0;
    	AES_KEY aes;
    	unsigned char key[AES_BLOCK_SIZE];
    	unsigned char iv[AES_BLOCK_SIZE];
    	if(NULL == source_string || NULL == des_string)
    	{
    		return;
    	}
    
    	//Generate own AES Key
    	memcpy(key,"1234567890123456",AES_BLOCK_SIZE);
    
    	// Set encryption key
    	for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
    	{
    		iv[iLoop] = 0;
    	}
    
    	if (AES_set_encrypt_key(key, 128, &aes) < 0) 
    	{
    		return ;
    	}
    
    	iLen = strlen(source_string)+1;
    
    	AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_ENCRYPT);
    
    }
    void aes_box_decrypt(unsigned char* source_string, unsigned char* des_string)
    {
    	int iLoop = 0;
    	int iLen =0;
    	AES_KEY aes;
    	unsigned char key[AES_BLOCK_SIZE];
    	unsigned char iv[AES_BLOCK_SIZE];
    	if(NULL == source_string || NULL == des_string)
    	{
    		return;
    	}
    
    	//Generate own AES Key
    	memcpy(key,"1234567890123456",AES_BLOCK_SIZE);
    
    	// Set encryption key
    	for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
    	{
    		iv[iLoop] = 0;
    	}
    
    	if (AES_set_decrypt_key(key, 128, &aes) < 0) 
    	{
    		return ;
    	}
    
    	iLen = strlen(source_string)+1;
    
    	AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_DECRYPT);
    }
    int main(int argc,char *argv[]) 
    {
    	unsigned char ucIsEncrypt = 3;  
    	unsigned char sourceStringTemp[100];
    	unsigned char dstStringTemp[100];
    	unsigned char printString[100];
    	unsigned long ulBase64SrcLen = 0;
    	unsigned long ulBase64DstLen = 100;
    	unsigned long ulPrintLen = 0;
    
    	memset(sourceStringTemp, 0 ,100);
    	memset(dstStringTemp, 255 ,100);
    	memset(printString, 0, 100);
    
    	if(argc < 2)
    	{
    		return 0;
    	}
    
    	strcpy((char*)sourceStringTemp, argv[1]);
    	ucIsEncrypt = atoi(argv[2]);
    
    	if(AES_ENCRYPT == ucIsEncrypt)
    	{
    		aes_box_encrypt(sourceStringTemp,dstStringTemp);
    
    		for (; 255!=dstStringTemp[ulBase64SrcLen]; ulBase64SrcLen++);
          
    		Base64Encode(dstStringTemp, ulBase64SrcLen , printString, &ulBase64DstLen);
    		printf("%s\r\n", printString);
    
    	} 
    	else if(AES_DECRYPT == ucIsEncrypt)
    	{        
    		ulBase64SrcLen = strlen(sourceStringTemp);        
    		Base64Decode(sourceStringTemp, ulBase64SrcLen, printString, &ulBase64DstLen);        
    		aes_box_decrypt(printString,dstStringTemp);
    		ulPrintLen = strlen(dstStringTemp);
    		dstStringTemp[ulPrintLen]='\0';
    
    		printf("%s", dstStringTemp);
    	}    
    
    	return 0;
    }
    

    同上,vs2008命令提示符进入AESPassword.exe当前目录:

    AESPassword.exe icd 1

    1为加密,0为解密
     

    错误:32位机器正常运行,但是在64位机器上面有“readyX.dll”错误

    工程属性——》配置属性——》C/C++——》常规——》检测64位可移植性问题

    另外:

    工程属性——》配置属性——》常规——》MFC的使用——》在静态库中使用MFC

     

    错误:在机器中运行AESPassword.exe,出现缺少“libeay32.dll”文件

    libeay32.dll文件为openssl源程序编译后的文件,将其放在AESPassword.exe同目录下即可。

     


     

    展开全文
  • 但是这里有个坑,mcrypt对秘钥的长度没有限制,传入多少长度都会参加加密,但是在openssl_encrypt中。key长度只能是16长度,>16长度后,只有前16位参与加密。 2.aes在php7以下用mcrypt实现代码: <?php...

    1.在php的世界里面mcrypt的生命肯定是已经走到了尽头,从php7.+开始已经不再支持mcrypt函数,需要使用openssl代替。但是这里有个坑,mcrypt对秘钥的长度没有限制,传入多少长度都会参加加密,但是在openssl_encrypt中。key长度只能是16长度,>16长度后,只有前16位参与加密。

    2.aes在php7以下用mcrypt实现代码:

    <?php
        class AES{
    /**
         * This was AES-128 / CBC / PKCS5Padding
         * return base64_encode string
         * @author Terry
         * @param string $plaintext
         * @param string $key
         * @return string
         */
        public static function AesEncrypt($plaintext,$key = null)
        {
            $plaintext = trim($plaintext);
            if ($plaintext == '') return '';
            $size = mcrypt_get_block_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);


            //PKCS5Padding
            $padding = $size - strlen($plaintext) % $size;
            // 添加Padding
            $plaintext .= str_repeat(chr($padding), $padding);


            $module = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, '');
            $key=self::substr($key, 0, mcrypt_enc_get_key_size($module));
      //var_dump($key);die;
            $iv = str_repeat("\0", $size);   //java里面的16个空数组对应的是\0.
      //var_dump($iv);die;
      //echo $key;die;
            /* Intialize encryption */
            mcrypt_generic_init($module, $key, $iv);


            /* Encrypt data */
            $encrypted = mcrypt_generic($module, $plaintext);


            /* Terminate encryption handler */
            mcrypt_generic_deinit($module);
            mcrypt_module_close($module);
            return base64_encode($encrypted);
        }

        /**
         * Returns the length of the given string.
         * If available uses the multibyte string function mb_strlen.
         * @param string $string the string being measured for length
         * @return integer the length of the string
         */
        private static function strlen($string)
        {
            return extension_loaded('mbstring') ? mb_strlen($string,'8bit') : strlen($string);
        }


        /**
         * Returns the portion of string specified by the start and length parameters.
         * If available uses the multibyte string function mb_substr
         * @param string $string the input string. Must be one character or longer.
         * @param integer $start the starting position
         * @param integer $length the desired portion length
         * @return string the extracted part of string, or FALSE on failure or an empty string.
         */
        private static function substr($string,$start,$length)
        {
            return extension_loaded('mbstring') ? mb_substr($string,$start,$length,'8bit') : substr($string,$start,$length);
        }
        /**
         * This was AES-128 / CBC / PKCS5Padding
         * @author Terry
         * @param string $encrypted     base64_encode encrypted string
         * @param string $key
         * @throws CException
         * @return string
         */
        public static function AesDecrypt($encrypted, $key = null)
        {
            if ($encrypted == '') return '';
            $ciphertext_dec = base64_decode($encrypted);
            $module = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, '');
            $key=self::substr($key, 0, mcrypt_enc_get_key_size($module));
            $iv = str_repeat("\0", 16);    //解密的初始化向量要和加密时一样。
            /* Initialize encryption module for decryption */
            mcrypt_generic_init($module, $key, $iv);


            /* Decrypt encrypted string */
            $decrypted = mdecrypt_generic($module, $ciphertext_dec);


            /* Terminate decryption handle and close module */
            mcrypt_generic_deinit($module);
            mcrypt_module_close($module);
            $a = rtrim($decrypted,"\0");


            return rtrim($decrypted,"\0");
        }
    }


     $plain="111111";
     echo  "加密后:".$miwen=AES::AesEncrypt($plain,'mkeymkeymkeymkey');
     echo "<br/>";
     echo "解密后:".AES::AesDecrypt($miwen,'mkeymkeymkeymkey');

    ?>

    运行结果:

    加密后:CEBqq9fGmsu4G87+MA2BWg== 解密后:111111

    3.php7.+以上openssl实现aes加密代码实现:

    <?php

    class Aes
     {
        public $key = '';
        public $iv = '';
        public function __construct( $config )
        {
            foreach ( $config as $k => $v ) {
                $this->$k = $v;
            }
        }
        //加密
        public function aesEn( $data ) {
            return  base64_encode( openssl_encrypt( $data, $this->method, $this->key,OPENSSL_RAW_DATA, $this->iv ) );

        }
        //解密

        public function aesDe( $data ) {
            return openssl_decrypt( base64_decode( $data ),  $this->method, $this->key,OPENSSL_RAW_DATA, $this->iv );
        }
    }


    $config = [
        'key' => 'mkeymkeymkeymkey', //加密key
        'iv' =>  str_repeat("\0", 16),//str_repeat("\0", 16)保证偏移量为16位,这里是16位空字符串,也可以和key一样16字符串,还可以是变化的,比如md5成16位原文,substr(md5("haha"),8,16),变化的需要保证同一个字符串加解密的iv保持一致。
        'method' => 'AES-128-CBC' //加密方式  # AES-256-CBC等
    ];

    //openssl_encrypt的第四个参数为1或者OPENSSL_RAW_DATA时填充方式为pks5padding或者pks7padding的结果一样,其他待验证
    $obj = new Aes( $config );
    //加密数据
    $miwen = $obj->aesEn( '111111' );
    echo "加密后:".$miwen;
    echo "<br/>";
    echo "解密后:".$obj->aesDe( $miwen );

    ?>

    运行结果:

    加密后:CEBqq9fGmsu4G87+MA2BWg==解密后:111111

    4.结果发现低版本的php的mcrypt和高版本php的openssl,在秘钥都是16位的情况下,加密和解密的结果是一致的。

    5.给mcrypt和openssl的秘钥都增加一位x看下结果:

    mcrpyt结果:

    加密后:6TyYm0gpdVOrEFDOXSy+bA==解密后:111111

    openssl结果:

    加密后:CEBqq9fGmsu4G87+MA2BWg==解密后:111111

     6.总结密钥长度增加一个x,变成17位后,mcrpyt加密后的值发生了变化,但是可以通过相同的密钥解密,openssl加密的值没有发生变化,说明增加到17位的x,根本没有参与加密。

    7.如果php程序由低版本mcrypt的aes加密升级到高版本的openssl的aes加密,在密钥不是16位的情况下,就会出现悲剧的情况。还有就是和一些其他语言接口对接,如果别的语言key不是16位,那么他加密后的串,用openssl无法解密。

    展开全文
  • AES加密openssl安装(1)

    千次阅读 2012-11-30 20:05:07
    补充:在VC2008命令提示中,运行命令 ———————————《openssl编程》—————————————————— linux下的安装 1)解压 openssl 开发包文件; 2)运行./config --prefix=/usr/local/openssl...

    补充:在VC2008命令提示中,运行命令

    ———————————《openssl编程》——————————————————

    linux下的安装

    1)解压 openssl 开发包文件;
    2)运行./config --prefix=/usr/local/openssl  (更多选项用./config  --help  来查看),可用的选项有:no-mdc2、no-cast no-rc2、no-rc5、no-ripemd、no-rc4 no-des  、no-md2、no-md4、no-idea  、no-aes、no-bf、no-err、no-dsa、no-dh、no-ec、no-hw、no-asm、no-krb5、no-dso  、no-threads  、no-zlib、DOPENSSL_NO_HASH_COMP、-DOPENSSL_NO_ERR、-DOPENSSL_NO_HW  、-DOPENSSL_NO_OCSP、-DOPENSSL_NO_SHA256 和-DOPENSSL_NO_SHA512 等。去掉不必要的内容可以减少生成库的大小。  若要生成 debug  版本的库和可执行程序加-g  或者-g3(openssl 中有很多宏,需要调试学习最好加上-g3)。
    3)make test   (可选)
    4)make install
    完成后,openssl 会被安装到/usr/local/openssl 目录,包括头文件目录 include、可执行文件目录 bin、man 在线帮助、库目录 lib 以及配置文件目录(ssl)。

    ——————————————网摘—————————————————————

    window编译与安装

    本文介绍在VC 中编译和使用OpenSSL的过程。
    一、编译OpenSSL
    在编译OpenSSL前,需要正确安装Perl,因为在编译OpenSSL时需要使用到该程序。
    下载最新版本的Perl:http://downloads.activestate.com/ActivePerl/Windows/5.8/ActivePerl-5.8.8.822-MSWin32-x86-280952.zip。然后安装之。
    下载最新版本的OpenSSL:http://www.openssl.org/source/openssl-0.9.8g.tar.gz
    然后将源码释放的c:\openssl-0.9.8g目录中。
    进入openssl源码目录。
    cd c:\openssl-0.9.8.g
    以下为参照该目录下的文件INSTALL.W32的执行过程:
    运行configure:
    perl Configure VC-WIN32 --prefix=c:/openssl
    创建Makefile文件:
    ms\do_ms
    编译动态库:
    nmake -f ms\ntdll.mak
    编译静态库:
    nmake -f ms\nt.mak
    测试动态库:
    nmake -f ms\ntdll.mak test
    测试静态库:
    nmake -f ms\nt.mak test
    安装动态库:
    nmake -f ms\ntdll.mak install
    安装静态库:
    nmake -f ms\nt.mak install
    清除上次动态库的编译,以便重新编译:
    nmake -f ms\ntdll.mak clean
    清除上次静态库的编译,以便重新编译:
    nmake -f ms\nt.mak clean
    二、使用OpenSSL
    在VC中配置使用以上的函数库:
    点击菜单:Tools -> Options,弹出对话框"Options",在该对话框中选择"Directories"标签。
    在"Show directories for:"的"Include files"选项中新增目录"C:\openssl\include";"Library files"选择中新增目录"C:\openssl\lib"。
    然后在需要链接OpenSSL函数库的工程中编译时加入"libeay32.lib"就可以了。
    三、问题
    我在链接OpenSSL的静态函数库时遇到类似以下的问题:
    Linking...
    msvcrt.lib(MSVCRT.dll) : error LNK2005: _strchr already defined in libcmtd.lib(strchr.obj)
    ...
    这是由于OpenSSL的静态函数库使用的是了VC的多线程DLL的Release版本,而我的程序使用了多线程静态链接的Release版本。
    调整OpenSSL的静态函数库使用的库函数版本即可,调整过程如下:
    编辑文件 ms\nt.mak,将该文件第19行
    "CFLAG= /MD /Ox /O2 /Ob2 /W3 /WX /Gs0 /GF /Gy /nologo -DOPENSSL_SYSNAME_WIN32 -DWIN32_LEAN_AND_MEAN -DL_ENDIAN -DDSO_WIN32 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE /Fdout32 -DOPENSSL_NO_CAMELLIA -DOPENSSL_NO_SEED -DOPENSSL_NO_RC5 -DOPENSSL_NO_MDC2 -DOPENSSL_NO_TLSEXT -DOPENSSL_NO_KRB5 -DOPENSSL_NO_DYNAMIC_ENGINE"
    中的"/MD"修改为"/MT"。然后重新编译安装OpenSSL即可。
    四、附录:在VC中对C/C++ 运行时库不同版本编译指令说明
    《在VC中对C/C++ 运行时库不同版本编译指令说明》(http://blog.yesky.com/271/dgkang/1737771.shtml)一文中详细介绍了连接不同版本库的编译指令如下:
    C Runtime Library:
    /MD MSVCRT.LIB 多线程DLL的Release版本
    /MDd MSVCRTD.LIB 多线程DLL的Debug版本
    /MT LIBCMT.LIB 多线程静态链接的Release版本
    /MTd LIBCMTD.LIB 多线程静态链接的Debug版本
    /clr MSVCMRT.LIB 托管代码和非托管代码混合
    /clr:pure MSVCURT.LIB 纯托管代码
    C++ Standard Library:
    /MD MSVCPRT.LIB 多线程DLL的Release版本
    /MDd MSVCPRTD.LIB 多线程DLL的Debug版本
    /MT LIBCPMT.LIB 多线程静态链接的Release版本
    /MTd LIBCPMTD.LIB 多线程静态链接的Debug版本

    linux下使用 

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <openssl/aes.h>
    
    void aes_box_encrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
        for(iLoop = 0; iLoop < 16; iLoop++)
        {
            key[iLoop] = 32 + iLoop;
        }
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_encrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string) + 1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_ENCRYPT);
    
    }
    
    void aes_box_decrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
        for(iLoop = 0; iLoop < 16; iLoop++)
        {
            key[iLoop] = 32 + iLoop;
        }
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_decrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string)+1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_DECRYPT);
    }
    
    int main(int argc,char *argv[]) 
    {
        unsigned char ucIsEncrypt = 3;  
        unsigned char sourceStringTemp[16];
        unsigned char dstStringTemp[16];
    
        memset(sourceStringTemp, 0 ,16);
        
        strcpy((char*)sourceStringTemp, argv[1]);
        ucIsEncrypt = atoi(argv[2]);
    
        if(AES_ENCRYPT == ucIsEncrypt)
        {
            aes_box_encrypt(sourceStringTemp,dstStringTemp);
        }
        else if(AES_DECRYPT == ucIsEncrypt)
        {
            aes_box_decrypt(sourceStringTemp,dstStringTemp);
        }
    
        printf("%s",dstStringTemp);
    
        return 0;
    }
    

    makefile

    SERVER = AESPassword
    TARGET = ${SERVER} 
    
    WORK_DIR = $(shell pwd)
    #tsp_root = $(shell pwd)/../../
    TARGET_DIR=${WORK_DIR}
    #HISISDK_DIR=${WORK_DIR}/../../../../../../
    
    OBJECTS =  AESPassword.o 
    
    CC=gcc
    
    LIB_PATH = -L${WORK_DIR}/dst/lib 
    
    CFLAGS =  -Wall -g
    
    LIBS = -lcrypto
    	
    INCLUDE_PATH = -I${WORK_DIR}/dst/include
    				
    
    VPATH = 
    
    
    .PHNOY: all
    all:  ${TARGET} clean_obj
    obj:  ${OBJECTS}
    
    ${SERVER}: ${OBJECTS} 
    	${CC}  -o ${TARGET_DIR}/${SERVER} ${OBJECTS} ${LIB_PATH} ${LIBS} ${CFLAGS}
    	
    %.o:%.c
    	${CC}   ${CFLAGS} -c $< ${INCLUDE_PATH} 
    
    
    #.PHNOY : clean
    clean_obj:
    	-rm ${OBJECTS}
    clean:
    	-rm -rf ${TARGET_DIR}/${SERVER} ${OBJECTS}
    
    


     


     

    window下使用 

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "openssl/aes.h"
    #pragma comment(lib, "4758cca.lib")
    #pragma comment(lib, "aep.lib")
    #pragma comment(lib, "atalla.lib")
    #pragma comment(lib, "4758cca.lib")
    #pragma comment(lib, "chil.lib")
    #pragma comment(lib, "capi.lib")
    #pragma comment(lib, "cswift.lib")
    #pragma comment(lib, "gmp.lib")
    #pragma comment(lib, "libeay32.lib")
    #pragma comment(lib, "nuron.lib")
    #pragma comment(lib, "padlock.lib")
    #pragma comment(lib, "ssleay32.lib")
    #pragma comment(lib, "gost.lib")
    #pragma comment(lib, "sureware.lib")
    #pragma comment(lib, "ubsec.lib")
    
    
    void aes_box_encrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
        for(iLoop = 0; iLoop < 16; iLoop++)
        {
            key[iLoop] = 32 + iLoop;
        }
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_encrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string)+1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_ENCRYPT);
    
    }
    
    void aes_box_decrypt(unsigned char* source_string, unsigned char* des_string)
    {
        int iLoop = 0;
        int iLen =0;
        AES_KEY aes;
        unsigned char key[AES_BLOCK_SIZE];
        unsigned char iv[AES_BLOCK_SIZE];
        if(NULL == source_string || NULL == des_string)
        {
            return;
        }
    
        //Generate own AES Key
        for(iLoop = 0; iLoop < 16; iLoop++)
        {
            key[iLoop] = 32 + iLoop;
        }
    
        // Set encryption key
        for (iLoop=0; iLoop<AES_BLOCK_SIZE; iLoop++) 
        {
            iv[iLoop] = 0;
        }
    
        if (AES_set_decrypt_key(key, 128, &aes) < 0) 
        {
            return ;
        }
    
        iLen = strlen(source_string)+1;
    
       AES_cbc_encrypt(source_string, des_string, iLen, &aes, iv, AES_DECRYPT);
    }
    
    int main(void) 
    {
       //  unsigned char ucIsEncrypt = 3;  
       //  unsigned char sourceStringTemp[16];
       //  unsigned char dstStringTemp[16];
     
       //  memset(sourceStringTemp, 0 ,16);
       //  
     	 //if (NULL == argv[1])
     	 //{
     		// return 0;
     	 //}
     
       //  strcpy((char*)sourceStringTemp, argv[1]);
       //  ucIsEncrypt = atoi(argv[2]);
     
       //  if(AES_ENCRYPT == ucIsEncrypt)
       //  {
       //      aes_box_encrypt(sourceStringTemp,dstStringTemp);
       //  }
       //  else if(AES_DECRYPT == ucIsEncrypt)
       //  {
       //      aes_box_decrypt(sourceStringTemp,dstStringTemp);
       //  }
     
       //  printf("%s\r\n",dstStringTemp);
    
    
    	char source[] = {"你好icd"};
    	char dstStringTemp[16+1] = {0};
    	char dst[16+1] = {0};
    
    	aes_box_encrypt(source,dstStringTemp);
    	
    	printf("要加密的内容:%s\r\n", source);
    	printf("加密后的内容:%s\r\n", dstStringTemp);
    
    	aes_box_decrypt(dstStringTemp, dst);
    
    	printf("解密后的内容:%s\r\n", dst);
    
       // return 0;
    }
    


     

     

    展开全文
  • I am trying to encrypt a string using AES ... The output of the online tool (http://aes.online-domain-tools.com/) and the bash openssl command do not match. Can anyone help me with what I am doing wr...
  • openssl——aes加密

    2017-03-16 11:16:11
    opensslaes加密接口,要求数据是AES_BLOCK_SIZE的整数倍,所以当源数据不是16的整数倍时,需要填充一些字节。一下是一个封装aes加密的例子:bool AESEncrypt(const std::string& key, const std::string& src, std...
  • 主要给大家介绍了关于Js如何通过AES加密后PHP利用Openssl解密的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • openssl aes 加密

    千次阅读 2013-05-28 18:23:49
    OpenSSL提供了AES加解密算法的API讲解 http://blog.csdn.net/sunspider107/article/details/7375816     OpenSSL初学总结 http://blog.csdn.net/lixiaomin_235/article/details/3637977   OpenSSL常用命令...
  • I'm trying to implement the following in Python:openssl enc -e -aes-256-cbc -base64 -k "Secret Passphrase" -in plaintext.txt -out ciphertext.txtopenssl enc -d -aes-256-cbc -base64 -k "Secret Passphras...
  • OpenSSL provides a popular (but insecure – see ...) command line interface for AES encryption:openssl aes-256-cbc -salt -in filename -out filename.encPython has support for AES in the shape of the ...
  • iOS RSA,AES加密(使用openssl)

    千次阅读 2017-09-12 16:45:07
    https://github.com/x2on/OpenSSL-for-iPhone下载下来后打开终端cd到这个目录,直接./build-libssl.sh运行脚本。 等待个几分钟,当看到  Build library for iOS… Build library for tvOS… Done 这里我们就编译好...
  • OpenSSL RSA AES加密解密C++源码
  • openssl AES加密

    2016-10-21 15:12:00
    此代码不涉及ECB和CBC等关联加密 #include <stdio.h> #include <string.h> #include <stdlib.h>...openssl/aes.h> #include <openssl/applink.c> #pragma commen...
  • I'm interfacing to a legacy Java application (the app cannot be changed) which is encrypting data using AES. Here is how the original Java code is instantiating the AES cipher:SecretKeySpec skeySpec ....
  • c++ 基于 opensslAES加密
  • AES五种加密模式openssl

    2014-04-02 09:07:57
    分组密码有五种工作体制:1. 电码本模式(Electronic Codebook Book (ECB));2.密码分组链接模式(Cipher Block Chaining (CBC))...3.计算器模式(Counter (CTR));...5.输出反馈模式(Output FeedBack (OFB))的实现。
  • 加密 AES 加密/解密使用 OpenSSL
  • PHP7及以上版本,AES加密解密。OPENSSL

    千次阅读 2020-06-29 08:28:50
    PHP7版本对应的AES/ECB/PKCS5Padding算法。... $data = openssl_encrypt($data, 'aes-128-ecb', base64_decode($key), OPENSSL_RAW_DATA); return base64_encode($data); } public static functi.
  • openSSL实现AES加密

    2017-10-29 10:48:00
    以下是AES加密的使用备忘。如果你有一定的密码学基础,那么就很好理解。代码是从网上弄下来的(原始地址已经忘记了),然后在尝试的过程中改了一点东西。其它的cbc、cfb、ecb加密方式的用法都是类似的,只是函数名...
  • C++ openssl aes加密失败

    2015-08-28 09:36:56
    我在使用opensslaes(cbc)加密字节超过96的字符串后,在解密就会少字符,下面是我写的代码,求大神指点下什么问题,AES一次加密的明文是有长度限制么? CooloiAES::CooloiAES() : MSG_LEN(0) { for(int i = ...
  • opensslaes加密

    千次阅读 2015-03-30 15:14:05
    本文转自... opensslaes加密(AES_cbc_encrypt 与 AES_encrypt 的编程案例)  2014-01-09 16:28:26| 分类: 软件安全以及传输 |举报 |字号 订阅 续前几天的一篇
  • opensslAES加密(base64编码) 【 AES加密 】 在这里插入代码片 AES算法的块(block)的长度固定为16字节。假设一个字符串在AES加密前的长度为cleanLen,加密后的长度为cipherLen,则二者有下面的关系,其中的“/...
  • OpenSSLAES加密的用法

    2020-07-03 10:47:45
    OpenSSLAES加密的用法》 作者: 游蓝海 原文链接: http://blog.csdn.net/you_lan_hai/article/details/50992719 转载请注明出处 使用API的时候,需要特别小心数据长度,我在初次使用的时候简直被弄的晕头转向,...
  • 一、AES加密算法
  •  本文以openssl-0.9.8l代码为基础,对openSSLAES加密引擎的代码做一个分析,这里侧重于应用的角度对代码进行分析,有关aes加密算法的原理等有很多介绍(例如:http://zh.wikipedia.org/zh-cn/AES),不在本文的讨论...
  • Linux下使用opensslAES加密-ECB模式

    千次阅读 2017-04-11 19:25:36
    最近需要用到AES加密,为了图方便就打算使用openssl自带的AES加密算法的API来实现。
  • openssl AES 加密/解密

    千次阅读 2019-02-15 16:51:17
    aes-cbc-128, PKCS7 填充方式为例。 以下为使用两种不同api的实现相同加解密的代码: int AesDecrypt(const std::string&amp; sessionkey, const std::string&amp; encrypted_data, const std::string&...
  • openssl实现RSA+AES加密

    2019-07-13 19:24:04
    RSA+AES加密是传输数据过程中常用的一种加密方式,通讯双方都要实现加密解密过程,作为java,有接口,直接调用就好了,然而作为C语言这一端,加解密起来就比较蛋疼了,最近折腾了一下,这里留个脚印 AES加密算法 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,931
精华内容 4,772
关键字:

aes加密命令openssl