rc2.go

Documentation: github.com/tjfoc/gmsm/pkcs12

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package rc2 implements the RC2 cipher
     6  /*
     7  https://www.ietf.org/rfc/rfc2268.txt
     8  http://people.csail.mit.edu/rivest/pubs/KRRR98.pdf
     9  
    10  This code is licensed under the MIT license.
    11  */
    12  package pkcs12
    13  
    14  import (
    15  	"crypto/cipher"
    16  	"encoding/binary"
    17  )
    18  
    19  // The rc2 block size in bytes
    20  const BlockSize = 8
    21  
    22  type rc2Cipher struct {
    23  	k [64]uint16
    24  }
    25  
    26  // New returns a new rc2 cipher with the given key and effective key length t1
    27  func New(key []byte, t1 int) (cipher.Block, error) {
    28  	// TODO(dgryski): error checking for key length
    29  	return &rc2Cipher{
    30  		k: expandKey(key, t1),
    31  	}, nil
    32  }
    33  
    34  func (*rc2Cipher) BlockSize() int { return BlockSize }
    35  
    36  var piTable = [256]byte{
    37  	0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
    38  	0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
    39  	0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
    40  	0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
    41  	0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
    42  	0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
    43  	0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
    44  	0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
    45  	0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
    46  	0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
    47  	0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
    48  	0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
    49  	0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
    50  	0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
    51  	0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
    52  	0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad,
    53  }
    54  
    55  func expandKey(key []byte, t1 int) [64]uint16 {
    56  
    57  	l := make([]byte, 128)
    58  	copy(l, key)
    59  
    60  	var t = len(key)
    61  	var t8 = (t1 + 7) / 8
    62  	var tm = byte(255 % uint(1<<(8+uint(t1)-8*uint(t8))))
    63  
    64  	for i := len(key); i < 128; i++ {
    65  		l[i] = piTable[l[i-1]+l[uint8(i-t)]]
    66  	}
    67  
    68  	l[128-t8] = piTable[l[128-t8]&tm]
    69  
    70  	for i := 127 - t8; i >= 0; i-- {
    71  		l[i] = piTable[l[i+1]^l[i+t8]]
    72  	}
    73  
    74  	var k [64]uint16
    75  
    76  	for i := range k {
    77  		k[i] = uint16(l[2*i]) + uint16(l[2*i+1])*256
    78  	}
    79  
    80  	return k
    81  }
    82  
    83  func rotl16(x uint16, b uint) uint16 {
    84  	return (x >> (16 - b)) | (x << b)
    85  }
    86  
    87  func (c *rc2Cipher) Encrypt(dst, src []byte) {
    88  
    89  	r0 := binary.LittleEndian.Uint16(src[0:])
    90  	r1 := binary.LittleEndian.Uint16(src[2:])
    91  	r2 := binary.LittleEndian.Uint16(src[4:])
    92  	r3 := binary.LittleEndian.Uint16(src[6:])
    93  
    94  	var j int
    95  
    96  	for j <= 16 {
    97  		// mix r0
    98  		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
    99  		r0 = rotl16(r0, 1)
   100  		j++
   101  
   102  		// mix r1
   103  		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
   104  		r1 = rotl16(r1, 2)
   105  		j++
   106  
   107  		// mix r2
   108  		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
   109  		r2 = rotl16(r2, 3)
   110  		j++
   111  
   112  		// mix r3
   113  		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
   114  		r3 = rotl16(r3, 5)
   115  		j++
   116  
   117  	}
   118  
   119  	r0 = r0 + c.k[r3&63]
   120  	r1 = r1 + c.k[r0&63]
   121  	r2 = r2 + c.k[r1&63]
   122  	r3 = r3 + c.k[r2&63]
   123  
   124  	for j <= 40 {
   125  
   126  		// mix r0
   127  		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
   128  		r0 = rotl16(r0, 1)
   129  		j++
   130  
   131  		// mix r1
   132  		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
   133  		r1 = rotl16(r1, 2)
   134  		j++
   135  
   136  		// mix r2
   137  		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
   138  		r2 = rotl16(r2, 3)
   139  		j++
   140  
   141  		// mix r3
   142  		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
   143  		r3 = rotl16(r3, 5)
   144  		j++
   145  
   146  	}
   147  
   148  	r0 = r0 + c.k[r3&63]
   149  	r1 = r1 + c.k[r0&63]
   150  	r2 = r2 + c.k[r1&63]
   151  	r3 = r3 + c.k[r2&63]
   152  
   153  	for j <= 60 {
   154  
   155  		// mix r0
   156  		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
   157  		r0 = rotl16(r0, 1)
   158  		j++
   159  
   160  		// mix r1
   161  		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
   162  		r1 = rotl16(r1, 2)
   163  		j++
   164  
   165  		// mix r2
   166  		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
   167  		r2 = rotl16(r2, 3)
   168  		j++
   169  
   170  		// mix r3
   171  		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
   172  		r3 = rotl16(r3, 5)
   173  		j++
   174  	}
   175  
   176  	binary.LittleEndian.PutUint16(dst[0:], r0)
   177  	binary.LittleEndian.PutUint16(dst[2:], r1)
   178  	binary.LittleEndian.PutUint16(dst[4:], r2)
   179  	binary.LittleEndian.PutUint16(dst[6:], r3)
   180  }
   181  
   182  func (c *rc2Cipher) Decrypt(dst, src []byte) {
   183  
   184  	r0 := binary.LittleEndian.Uint16(src[0:])
   185  	r1 := binary.LittleEndian.Uint16(src[2:])
   186  	r2 := binary.LittleEndian.Uint16(src[4:])
   187  	r3 := binary.LittleEndian.Uint16(src[6:])
   188  
   189  	j := 63
   190  
   191  	for j >= 44 {
   192  		// unmix r3
   193  		r3 = rotl16(r3, 16-5)
   194  		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
   195  		j--
   196  
   197  		// unmix r2
   198  		r2 = rotl16(r2, 16-3)
   199  		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
   200  		j--
   201  
   202  		// unmix r1
   203  		r1 = rotl16(r1, 16-2)
   204  		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
   205  		j--
   206  
   207  		// unmix r0
   208  		r0 = rotl16(r0, 16-1)
   209  		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
   210  		j--
   211  	}
   212  
   213  	r3 = r3 - c.k[r2&63]
   214  	r2 = r2 - c.k[r1&63]
   215  	r1 = r1 - c.k[r0&63]
   216  	r0 = r0 - c.k[r3&63]
   217  
   218  	for j >= 20 {
   219  		// unmix r3
   220  		r3 = rotl16(r3, 16-5)
   221  		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
   222  		j--
   223  
   224  		// unmix r2
   225  		r2 = rotl16(r2, 16-3)
   226  		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
   227  		j--
   228  
   229  		// unmix r1
   230  		r1 = rotl16(r1, 16-2)
   231  		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
   232  		j--
   233  
   234  		// unmix r0
   235  		r0 = rotl16(r0, 16-1)
   236  		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
   237  		j--
   238  
   239  	}
   240  
   241  	r3 = r3 - c.k[r2&63]
   242  	r2 = r2 - c.k[r1&63]
   243  	r1 = r1 - c.k[r0&63]
   244  	r0 = r0 - c.k[r3&63]
   245  
   246  	for j >= 0 {
   247  
   248  		// unmix r3
   249  		r3 = rotl16(r3, 16-5)
   250  		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
   251  		j--
   252  
   253  		// unmix r2
   254  		r2 = rotl16(r2, 16-3)
   255  		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
   256  		j--
   257  
   258  		// unmix r1
   259  		r1 = rotl16(r1, 16-2)
   260  		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
   261  		j--
   262  
   263  		// unmix r0
   264  		r0 = rotl16(r0, 16-1)
   265  		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
   266  		j--
   267  
   268  	}
   269  
   270  	binary.LittleEndian.PutUint16(dst[0:], r0)
   271  	binary.LittleEndian.PutUint16(dst[2:], r1)
   272  	binary.LittleEndian.PutUint16(dst[4:], r2)
   273  	binary.LittleEndian.PutUint16(dst[6:], r3)
   274  }
   275
View as plain text