You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
169 lines
4.6 KiB
169 lines
4.6 KiB
'use strict';
|
|
|
|
var assert = require('assert');
|
|
|
|
var des = require('../');
|
|
var utils = des.utils;
|
|
|
|
var fixtures = require('./fixtures');
|
|
var bin = fixtures.bin;
|
|
|
|
describe('utils', function() {
|
|
describe('IP', function() {
|
|
it('should permute properly', function() {
|
|
var out = new Array(2);
|
|
var inp = [
|
|
bin('00000001 00100011 01000101 01100111'),
|
|
bin('10001001 10101011 11001101 11101111')
|
|
];
|
|
|
|
utils.ip(inp[0], inp[1], out, 0);
|
|
|
|
var expected = [
|
|
bin('11001100 00000000 11001100 11111111'),
|
|
bin('11110000 10101010 11110000 10101010')
|
|
];
|
|
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
|
|
it('should rev-permute properly', function() {
|
|
var out = new Array(2);
|
|
var inp = [
|
|
bin('11001100 00000000 11001100 11111111'),
|
|
bin('11110000 10101010 11110000 10101010')
|
|
];
|
|
|
|
utils.rip(inp[0], inp[1], out, 0);
|
|
|
|
var expected = [
|
|
bin('00000001 00100011 01000101 01100111'),
|
|
bin('10001001 10101011 11001101 11101111')
|
|
];
|
|
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
});
|
|
|
|
describe('PC1', function() {
|
|
it('should permute properly', function() {
|
|
var out = new Array(2);
|
|
var inp = [
|
|
bin('00010011 00110100 01010111 01111001'),
|
|
bin('10011011 10111100 11011111 11110001')
|
|
];
|
|
|
|
utils.pc1(inp[0], inp[1], out, 0);
|
|
|
|
var expected = [
|
|
bin('1111000 0110011 0010101 0101111'),
|
|
bin('0101010 1011001 1001111 0001111')
|
|
];
|
|
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
});
|
|
|
|
describe('r28shl', function() {
|
|
it('should shl properly', function() {
|
|
assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 1),
|
|
bin('1110000110011001010101011111'));
|
|
|
|
assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 1),
|
|
bin('1010101011001100111100011110'));
|
|
|
|
assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 4),
|
|
bin('0000110011001010101011111111'));
|
|
|
|
assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 4),
|
|
bin('0101011001100111100011110101'));
|
|
});
|
|
});
|
|
|
|
describe('PC2', function() {
|
|
it('should permute properly', function() {
|
|
var out = new Array(2);
|
|
var inp = [
|
|
bin('1110000 1100110 0101010 1011111'),
|
|
bin('1010101 0110011 0011110 0011110')
|
|
];
|
|
|
|
utils.pc2(inp[0], inp[1], out, 0);
|
|
|
|
var expected = [
|
|
bin('000110 110000 001011 101111'),
|
|
bin('111111 000111 000001 110010')
|
|
];
|
|
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
});
|
|
|
|
describe('readUInt32BE', function() {
|
|
it('should read number properly', function() {
|
|
var a = [ 0xde, 0xad, 0xbe, 0xef ];
|
|
var o = utils.readUInt32BE(a, 0);
|
|
assert.equal(o, 0xdeadbeef);
|
|
});
|
|
});
|
|
|
|
describe('writeUInt32BE', function() {
|
|
it('should read number properly', function() {
|
|
var a = [ 0, 0, 0, 0 ];
|
|
utils.writeUInt32BE(a, 0xdeadbeef, 0);
|
|
var expected = [ 0xde, 0xad, 0xbe, 0xef ];
|
|
assert.deepEqual(a, expected);
|
|
});
|
|
});
|
|
|
|
describe('expand', function() {
|
|
it('should expand', function() {
|
|
var out = [ 0, 0 ];
|
|
utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1010'), out, 0);
|
|
var expected = [
|
|
bin('011110 100001 010101 010101'),
|
|
bin('011110 100001 010101 010101')
|
|
];
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
|
|
it('should expand with low 1', function() {
|
|
var out = [ 0, 0 ];
|
|
utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1011'), out, 0);
|
|
var expected = [
|
|
bin('111110 100001 010101 010101'),
|
|
bin('011110 100001 010101 010111')
|
|
];
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
|
|
it('should expand with low 1', function() {
|
|
var out = [ 0, 0 ];
|
|
utils.expand(bin('10100010 01011100 00001011 11110100'), out, 0);
|
|
var expected = [
|
|
bin('010100 000100 001011 111000'),
|
|
bin('000001 010111 111110 101001')
|
|
];
|
|
assert.deepEqual(out, expected);
|
|
});
|
|
});
|
|
|
|
describe('substitute', function() {
|
|
it('should substitute', function() {
|
|
var input = [
|
|
bin('011000 010001 011110 111010'),
|
|
bin('100001 100110 010100 100111')
|
|
];
|
|
var output = utils.substitute(input[0], input[1]);
|
|
assert.equal(output, bin('0101 1100 1000 0010 1011 0101 1001 0111'));
|
|
});
|
|
});
|
|
|
|
describe('permute', function() {
|
|
it('should permute', function() {
|
|
var output = utils.permute(
|
|
bin('0101 1100 1000 0010 1011 0101 1001 0111'));
|
|
assert.equal(output, bin('0010 0011 0100 1010 1010 1001 1011 1011'));
|
|
});
|
|
});
|
|
});
|