from:http://blog.csdn.net/mao0514/article/details/52930944

SM4是我们自己国家的一个分组密码算法，是国家密码管理局于2012年发布的。网址戳→_→：http://www.cnnic.NET.cn/jscx/mixbz/sm4/

具体的密码标准和算法官方有非常详尽的PDF文档以供查阅，戳→_→：http://218.241.108.63/wiki/images/2/22/SM4%E5%88%86%E7%BB%84%E5%AF%86%E7%A0%81%E7%AE%97%E6%B3%95.pdf
算法的源码实现官方也有相应的示例源码，戳→_→：
http://218.241.108.63/wiki/index.PHP/File:Sm2_sm3_sm4_c%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0.zip
先说说啥是分组密码算法：
分组密码算法——国际DES、国产SM4分组密码就是将明文数据按固定长度进行分组，然后在同一密钥控制下逐组进行加密，从而将各个明文分组变换成一个等长的密文分组的密码。其中二进制明文分组的长度称为该分组密码的分组规模。

SM4密码算法的整体结构图如下：

在SM4的源代码中存在如下几个函数:

  1. void sm4_setkey_enc(sm4_context *ctx，unsigned char key[16])
  2. void sm4_setkey_dec(sm4_context *ctx，unsigned char key[16])
  3. void sm4_crypt_ecb( sm4_context *ctx,int mode,int length, unsigned char *input,unsigned char *output)
  4. void sm4_crypt_cbc( sm4_context *ctx,int mode,int length,unsigned char iv[16],unsigned char *input,unsigned char *output )
  5. static void sm4_setkey( unsigned long SK[32], unsigned char key[16] )

还有一个非常重要的结构体：sm4_context

  1. typedef struct
  2. {
  3. int mode;                   /*!<  encrypt/decrypt   */
  4. unsigned long sk[32];       /*!<  SM4 subkeys       */
  5. }sm4_context;

先说结构体：
sm4_context结构体中的Mode控制是加密还是解密，sk则表示子密钥，也称作轮密钥。

第一个函数： void sm4_setkey_enc(sm4_context *ctx，unsigned char key[16])
这个函数是用来设置加密密钥的，一个参数分别为sm4_context *ctx和一个key。
其内部会调用static void sm4_setkey( unsigned long SK[32], unsigned char key[16] )函数
这个函数是用来设置密钥的，这个函数内部会对当前传入的主密钥进行32轮的迭代，每次迭代的轮密钥都被存放到ctx结构中的sk数组中。
void sm4_setkey_dec(sm4_context *ctx，unsigned char key[16])函数就是解密函数，过程为上述过程的逆序过程。
第二个函数：void sm4_crypt_ecb( sm4_context *ctx,int mode,int length, unsigned char 
这个函数的作用是使用ecb模式（ECB（Electronic Codebook，电码本）模式是分组密码的一种最基本的工作模式。同样，sm4_crypt_cbc函数则是使用的CBC模式，也就是分组链接模式）来对内容进行加密，内部也是一个循环，根据length的长度来进行循环，每次循环都调用sm4_one_round进行加密或者解密，到底是加密还是解密，主要是根据第二个参数Mode来进行决定。
以上就是整个SM4算法的函数简介，运用这些函数接口，我们不需要知道内部的具体实现，就可以使用sm4加密算法来对我们的数据进行加解密，十分的方便。

  1. /*测试代码
  2. * SM4/SMS4 algorithm test programme
  3. * 2012-4-21
  4. */
  5. #include <string.h>
  6. #include <stdio.h>
  7. #include "sm4.h"
  8. int main()
  9. {
  10. unsigned char key[16] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
  11. unsigned char input[16] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
  12. unsigned char output[16];
  13. sm4_context ctx;
  14. unsigned long i;
  15. //encrypt standard testing vector
  16. sm4_setkey_enc(&ctx,key);
  17. sm4_crypt_ecb(&ctx,1,16,input,output);
  18. for(i=0;i<16;i++)
  19. printf("%02x ", output[i]);
  20. printf("\n");
  21. //decrypt testing
  22. sm4_setkey_dec(&ctx,key);
  23. sm4_crypt_ecb(&ctx,0,16,output,output);
  24. for(i=0;i<16;i++)
  25. printf("%02x ", output[i]);
  26. printf("\n");
  27. return 0;
  28. }
  1. /**
  2. * \file sm4.h
  3. */
  4. #ifndef XYSSL_SM4_H
  5. #define XYSSL_SM4_H
  6. #define SM4_ENCRYPT     1
  7. #define SM4_DECRYPT     0
  8. /**
  9. * \brief          SM4 context structure
  10. */
  11. typedef struct
  12. {
  13. int mode;                   /*!<  encrypt/decrypt   */
  14. unsigned long sk[32];       /*!<  SM4 subkeys       */
  15. }
  16. sm4_context;
  17. #ifdef __cplusplus
  18. extern "C" {
  19. #endif
  20. /**
  21. * \brief          SM4 key schedule (128-bit, encryption)
  22. *
  23. * \param ctx      SM4 context to be initialized
  24. * \param key      16-byte secret key
  25. */
  26. void sm4_setkey_enc( sm4_context *ctx, unsigned char key[16] );
  27. /**
  28. * \brief          SM4 key schedule (128-bit, decryption)
  29. *
  30. * \param ctx      SM4 context to be initialized
  31. * \param key      16-byte secret key
  32. */
  33. void sm4_setkey_dec( sm4_context *ctx, unsigned char key[16] );
  34. /**
  35. * \brief          SM4-ECB block encryption/decryption
  36. * \param ctx      SM4 context
  37. * \param mode     SM4_ENCRYPT or SM4_DECRYPT
  38. * \param length   length of the input data
  39. * \param input    input block
  40. * \param output   output block
  41. */
  42. void sm4_crypt_ecb( sm4_context *ctx,
  43. int mode,
  44. int length,
  45. unsigned char *input,
  46. unsigned char *output);
  47. #ifdef __cplusplus
  48. }
  49. #endif
  50. #endif /* sm4.h */
    1. /*
    2. * SM4 Encryption alogrithm (SMS4 algorithm)
    3. * GM/T 0002-2012 Chinese National Standard ref:http://www.oscca.gov.cn/
    4. * thanks to Xyssl
    5. * thnaks and refers to http://hi.baidu.com/numax/blog/item/80addfefddfb93e4cf1b3e61.html
    6. * author:goldboar
    7. * email:goldboar@163.com
    8. * 2012-4-20
    9. */
    10. // Test vector 1
    11. // plain: 01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
    12. // key:   01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
    13. //    round key and temp computing result:
    14. //    rk[ 0] = f12186f9 X[ 0] = 27fad345
    15. //    rk[ 1] = 41662b61 X[ 1] = a18b4cb2
    16. //    rk[ 2] = 5a6ab19a X[ 2] = 11c1e22a
    17. //    rk[ 3] = 7ba92077 X[ 3] = cc13e2ee
    18. //    rk[ 4] = 367360f4 X[ 4] = f87c5bd5
    19. //    rk[ 5] = 776a0c61 X[ 5] = 33220757
    20. //    rk[ 6] = b6bb89b3 X[ 6] = 77f4c297
    21. //    rk[ 7] = 24763151 X[ 7] = 7a96f2eb
    22. //    rk[ 8] = a520307c X[ 8] = 27dac07f
    23. //    rk[ 9] = b7584dbd X[ 9] = 42dd0f19
    24. //    rk[10] = c30753ed X[10] = b8a5da02
    25. //    rk[11] = 7ee55b57 X[11] = 907127fa
    26. //    rk[12] = 6988608c X[12] = 8b952b83
    27. //    rk[13] = 30d895b7 X[13] = d42b7c59
    28. //    rk[14] = 44ba14af X[14] = 2ffc5831
    29. //    rk[15] = 104495a1 X[15] = f69e6888
    30. //    rk[16] = d120b428 X[16] = af2432c4
    31. //    rk[17] = 73b55fa3 X[17] = ed1ec85e
    32. //    rk[18] = cc874966 X[18] = 55a3ba22
    33. //    rk[19] = 92244439 X[19] = 124b18aa
    34. //    rk[20] = e89e641f X[20] = 6ae7725f
    35. //    rk[21] = 98ca015a X[21] = f4cba1f9
    36. //    rk[22] = c7159060 X[22] = 1dcdfa10
    37. //    rk[23] = 99e1fd2e X[23] = 2ff60603
    38. //    rk[24] = b79bd80c X[24] = eff24fdc
    39. //    rk[25] = 1d2115b0 X[25] = 6fe46b75
    40. //    rk[26] = 0e228aeb X[26] = 893450ad
    41. //    rk[27] = f1780c81 X[27] = 7b938f4c
    42. //    rk[28] = 428d3654 X[28] = 536e4246
    43. //    rk[29] = 62293496 X[29] = 86b3e94f
    44. //    rk[30] = 01cf72e5 X[30] = d206965e
    45. //    rk[31] = 9124a012 X[31] = 681edf34
    46. // cypher: 68 1e df 34 d2 06 96 5e 86 b3 e9 4f 53 6e 42 46
    47. // test vector 2
    48. // the same key and plain 1000000 times coumpting
    49. // plain:  01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
    50. // key:    01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10
    51. // cypher: 59 52 98 c7 c6 fd 27 1f 04 02 f8 04 c3 3d 3f 66
    52. #include "sm4.h"
    53. #include <string.h>
    54. #include <stdio.h>
    55. /*
    56. * 32-bit integer manipulation macros (big endian)
    57. */
    58. #ifndef GET_ULONG_BE
    59. #define GET_ULONG_BE(n,b,i)                             \
    60. {                                                       \
    61. (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
    62. | ( (unsigned long) (b)[(i) + 1] << 16 )        \
    63. | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
    64. | ( (unsigned long) (b)[(i) + 3]       );       \
    65. }
    66. #endif
    67. #ifndef PUT_ULONG_BE
    68. #define PUT_ULONG_BE(n,b,i)                             \
    69. {                                                       \
    70. (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
    71. (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
    72. (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
    73. (b)[(i) + 3] = (unsigned char) ( (n)       );       \
    74. }
    75. #endif
    76. /*
    77. *rotate shift left marco definition
    78. *
    79. */
    80. #define  SHL(x,n) (((x) & 0xFFFFFFFF) << n)
    81. #define ROTL(x,n) (SHL((x),n) | ((x) >> (32 - n)))
    82. #define SWAP(a,b) { unsigned long t = a; a = b; b = t; t = 0; }
    83. /*
    84. * Expanded SM4 S-boxes
    85. /* Sbox table: 8bits input convert to 8 bits output*/
    86. static const unsigned char SboxTable[16][16] =
    87. {
    88. {0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05},
    89. {0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99},
    90. {0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62},
    91. {0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6},
    92. {0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8},
    93. {0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35},
    94. {0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87},
    95. {0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e},
    96. {0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1},
    97. {0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3},
    98. {0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f},
    99. {0xd5,0xdb,0x37,0x45,0xde,0xfd,0x8e,0x2f,0x03,0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51},
    100. {0x8d,0x1b,0xaf,0x92,0xbb,0xdd,0xbc,0x7f,0x11,0xd9,0x5c,0x41,0x1f,0x10,0x5a,0xd8},
    101. {0x0a,0xc1,0x31,0x88,0xa5,0xcd,0x7b,0xbd,0x2d,0x74,0xd0,0x12,0xb8,0xe5,0xb4,0xb0},
    102. {0x89,0x69,0x97,0x4a,0x0c,0x96,0x77,0x7e,0x65,0xb9,0xf1,0x09,0xc5,0x6e,0xc6,0x84},
    103. {0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48}
    104. };
    105. /* System parameter */
    106. static const unsigned long FK[4] = {0xa3b1bac6,0x56aa3350,0x677d9197,0xb27022dc};
    107. /* fixed parameter */
    108. static const unsigned long CK[32] =
    109. {
    110. 0x00070e15,0x1c232a31,0x383f464d,0x545b6269,
    111. 0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
    112. 0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,
    113. 0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
    114. 0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,
    115. 0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
    116. 0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,
    117. 0x10171e25,0x2c333a41,0x484f565d,0x646b7279
    118. };
    119. /*
    120. * private function:
    121. * look up in SboxTable and get the related value.
    122. * args:    [in] inch: 0x00~0xFF (8 bits unsigned value).
    123. */
    124. static unsigned char sm4Sbox(unsigned char inch)
    125. {
    126. unsigned char *pTable = (unsigned char *)SboxTable;
    127. unsigned char retVal = (unsigned char)(pTable[inch]);
    128. return retVal;
    129. }
    130. /*
    131. * private F(Lt) function:
    132. * "T algorithm" == "L algorithm" + "t algorithm".
    133. * args:    [in] a: a is a 32 bits unsigned value;
    134. * return: c: c is calculated with line algorithm "L" and nonline algorithm "t"
    135. */
    136. static unsigned long sm4Lt(unsigned long ka)
    137. {
    138. unsigned long bb = 0;
    139. unsigned long c = 0;
    140. unsigned char a[4];
    141. unsigned char b[4];
    142. PUT_ULONG_BE(ka,a,0)
    143. b[0] = sm4Sbox(a[0]);
    144. b[1] = sm4Sbox(a[1]);
    145. b[2] = sm4Sbox(a[2]);
    146. b[3] = sm4Sbox(a[3]);
    147. GET_ULONG_BE(bb,b,0)
    148. c =bb^(ROTL(bb, 2))^(ROTL(bb, 10))^(ROTL(bb, 18))^(ROTL(bb, 24));
    149. return c;
    150. }
    151. /*
    152. * private F function:
    153. * Calculating and getting encryption/decryption contents.
    154. * args:    [in] x0: original contents;
    155. * args:    [in] x1: original contents;
    156. * args:    [in] x2: original contents;
    157. * args:    [in] x3: original contents;
    158. * args:    [in] rk: encryption/decryption key;
    159. * return the contents of encryption/decryption contents.
    160. */
    161. static unsigned long sm4F(unsigned long x0, unsigned long x1, unsigned long x2, unsigned long x3, unsigned long rk)
    162. {
    163. return (x0^sm4Lt(x1^x2^x3^rk));
    164. }
    165. /* private function:
    166. * Calculating round encryption key.
    167. * args:    [in] a: a is a 32 bits unsigned value;
    168. * return: sk[i]: i{0,1,2,3,...31}.
    169. */
    170. static unsigned long sm4CalciRK(unsigned long ka)
    171. {
    172. unsigned long bb = 0;
    173. unsigned long rk = 0;
    174. unsigned char a[4];
    175. unsigned char b[4];
    176. PUT_ULONG_BE(ka,a,0)
    177. b[0] = sm4Sbox(a[0]);
    178. b[1] = sm4Sbox(a[1]);
    179. b[2] = sm4Sbox(a[2]);
    180. b[3] = sm4Sbox(a[3]);
    181. GET_ULONG_BE(bb,b,0)
    182. rk = bb^(ROTL(bb, 13))^(ROTL(bb, 23));
    183. return rk;
    184. }
    185. static void sm4_setkey( unsigned long SK[32], unsigned char key[16] )
    186. {
    187. unsigned long MK[4];
    188. unsigned long k[36];
    189. unsigned long i = 0;
    190. GET_ULONG_BE( MK[0], key, 0 );
    191. GET_ULONG_BE( MK[1], key, 4 );
    192. GET_ULONG_BE( MK[2], key, 8 );
    193. GET_ULONG_BE( MK[3], key, 12 );
    194. k[0] = MK[0]^FK[0];
    195. k[1] = MK[1]^FK[1];
    196. k[2] = MK[2]^FK[2];
    197. k[3] = MK[3]^FK[3];
    198. for(; i<32; i++)
    199. {
    200. k[i+4] = k[i] ^ (sm4CalciRK(k[i+1]^k[i+2]^k[i+3]^CK[i]));
    201. SK[i] = k[i+4];
    202. }
    203. }
    204. /*
    205. * SM4 standard one round processing
    206. *
    207. */
    208. static void sm4_one_round( unsigned long sk[32],
    209. unsigned char input[16],
    210. unsigned char output[16] )
    211. {
    212. unsigned long i = 0;
    213. unsigned long ulbuf[36];
    214. memset(ulbuf, 0, sizeof(ulbuf));
    215. GET_ULONG_BE( ulbuf[0], input, 0 )
    216. GET_ULONG_BE( ulbuf[1], input, 4 )
    217. GET_ULONG_BE( ulbuf[2], input, 8 )
    218. GET_ULONG_BE( ulbuf[3], input, 12 )
    219. while(i<32)
    220. {
    221. ulbuf[i+4] = sm4F(ulbuf[i], ulbuf[i+1], ulbuf[i+2], ulbuf[i+3], sk[i]);
    222. // #ifdef _DEBUG
    223. //        printf("rk(%02d) = 0x%08x,  X(%02d) = 0x%08x \n",i,sk[i], i, ulbuf[i+4] );
    224. // #endif
    225. i++;
    226. }
    227. PUT_ULONG_BE(ulbuf[35],output,0);
    228. PUT_ULONG_BE(ulbuf[34],output,4);
    229. PUT_ULONG_BE(ulbuf[33],output,8);
    230. PUT_ULONG_BE(ulbuf[32],output,12);
    231. }
    232. /*
    233. * SM4 key schedule (128-bit, encryption)
    234. */
    235. void sm4_setkey_enc( sm4_context *ctx, unsigned char key[16] )
    236. {
    237. ctx->mode = SM4_ENCRYPT;
    238. sm4_setkey( ctx->sk, key );
    239. }
    240. /*
    241. * SM4 key schedule (128-bit, decryption)
    242. */
    243. void sm4_setkey_dec( sm4_context *ctx, unsigned char key[16] )
    244. {
    245. int i;
    246. ctx->mode = SM4_ENCRYPT;
    247. sm4_setkey( ctx->sk, key );
    248. for( i = 0; i < 16; i ++ )
    249. {
    250. SWAP( ctx->sk[ i ], ctx->sk[ 31-i] );
    251. }
    252. }
    253. /*
    254. * SM4-ECB block encryption/decryption
    255. */
    256. void sm4_crypt_ecb( sm4_context *ctx,
    257. int mode,
    258. int length,
    259. unsigned char *input,
    260. unsigned char *output)
    261. {
    262. while( length > 0 )
    263. {
    264. sm4_one_round( ctx->sk, input, output );
    265. input  += 16;
    266. output += 16;
    267. length -= 16;
    268. }
    269. }

sm4算法（附源码、测试代码）的更多相关文章

  1. VS2010版的Speex音频处理模块(附源码+测试demo)

    开源的Speex代码内部包含了VS2003,05,08工程,但是直接编译总有一些要设置的地方,虽说也不是很复杂,但是对于不是很了解VS的同学来说还是要折腾一阵,所以我弄了一个可以直接使用的版本,当然是 ...

  2. 单独编译和使用webrtc音频增益模块(附完整源码+测试音频文件)

    webrtc的音频处理模块分为降噪ns和nsx,回音消除aec,回声控制acem,音频增益agc,静音检测部分.另外webrtc已经封装好了一套音频处理模块APM,如果不是有特殊必要,使用者如果要用到 ...

  3. SM4密码算法（附源码）

    SM4是我们自己国家的一个分组密码算法,是国家密码管理局于2012年发布的.网址戳→_→:http://www.cnnic.NET.cn/jscx/mixbz/sm4/ 具体的密码标准和算法官方有非常 ...

  4. 13行代码实现：Python实时视频采集（附源码）

    一.前言 本文是<人脸识别完整项目实战>系列博文第3部分:程序设计篇(Python版),第1节<Python实时视频采集程序设计>,本章内容系统介绍:基于Python+open ...

  5. 单独编译和使用webrtc音频降噪模块(附完整源码+测试音频文件)

    单独编译和使用webrtc音频增益模块(附完整源码+测试音频文件) 单独编译和使用webrtc音频回声消除模块(附完整源码+测试音频文件) webrtc的音频处理模块分为降噪ns,回音消除aec,回声 ...

  6. 单独编译和使用webrtc音频回声消除模块(附完整源码+测试音频文件)

    单独编译和使用webrtc音频降噪模块(附完整源码+测试音频文件) 单独编译和使用webrtc音频增益模块(附完整源码+测试音频文件) 说实话很不想写这篇文章,因为这和我一贯推崇的最好全部编译并使用w ...

  7. 基于Python接口自动化测试框架+数据与代码分离(进阶篇)附源码

    引言 在上一篇<基于Python接口自动化测试框架(初级篇)附源码>讲过了接口自动化测试框架的搭建,最核心的模块功能就是测试数据库初始化,再来看看之前的框架结构: 可以看出testcase ...

  8. C#编程总结（七）数据加密——附源码

    C#编程总结(七)数据加密——附源码 概述 数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理,使其成为不可读的一段代码,通常称为“密文”,使其只能在输入相应的密钥之后才能显示出本来内容 ...

  9. swfupload多文件上传[附源码]

    swfupload多文件上传[附源码] 文件上传这东西说到底有时候很痛,原来的asp.net服务器控件提供了很简单的上传,但是有回传,还没有进度条提示.这次我们演示利用swfupload多文件上传,项 ...

随机推荐

  1. 手把手教你入门Yii2框架-1

    前言概述: 我是一名PHP开发工程师,最拿手的是版本2.0的Yii框架,在培训班里老师没教我Yii框架,只是由于我弟弟(同行)擅长Yii框架,所以我用得最多的就是Yii2.0,后台我学了ThinkPH ...

  2. Java搭建WebSocket的两种方式

    下面分别介绍搭建方法:一.直接使用Java EE的api进行搭建.一共3个步骤:1.添加依赖<dependency>    <groupId>javax</groupId ...

  3. Tensorflow学习教程------模型参数和网络结构保存且载入,输入一张手写数字图片判断是几

    首先是模型参数和网络结构的保存 #coding:utf-8 import tensorflow as tf from tensorflow.examples.tutorials.mnist impor ...

  4. quartz定时定时任务执行两次

    quartz框架没问题. 流程: sping-quartz配置 <?xml version="1.0" encoding="UTF-8"?> < ...

  5. Code Style for OI

    Code Style for OI #include #define 尽量少用 #include 能#include <foo>就不#include "foo" #if ...

  6. redis备忘录

    Redis 是一个基于内存的高性能key-value数据库.Redis本质上是一个Key-Value类型的内存数据库,很像memcached,整个数据库统统加载在内存当中进行操作,定期通过异步操作把数 ...

  7. java合并一个文件夹下所有txt文件，输出到另一个txt

    最近写了个单元测试,递归调用方法,把同一个文件夹里所有的txt合并输出到一个txt文件.参考了两个博客,分别是已有的方法,还有个就是检测txt文件所用编码的技术贴.如果不检测txt文件的编码,那么转换 ...

  8. MplayerX 安装

    从老的笔记本中,把MplayerX.app 复制到新笔记本并放到应用程序目录中,可以直接用. 但播放时出现花屏,百度得到原因是新的硬件加速不支持, 解决办法是,在偏好设置-> 高级 -> ...

  9. 34）static 静态成员和静态成员函数

    1) static修饰的方法,只能在这个文件中使用,比如你是多文件编程,别的文件即使引入了我的 .h文件  但那时我的static方法也是不能用 2)C++的static的成员变量   比如  sta ...

  10. Qt QPixmap和QImage的相互转换

    QPixmap转为Image: QPixmap pixmap; pixmap.load("../Image/1.jpg"); QImage tempImage = pixmap.t ...