Blocktrail\SDK\V3Crypt\Encryption

Complexity

Total Complexity

4

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	6

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	encrypt()	0	6	1
A	decrypt()	0	22	1
A	encryptWithSaltAndIV()	0	16	2

<?php

namespace Blocktrail\SDK\V3Crypt;

use AESGCM\AESGCM;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;
use BitWasp\Buffertools\Buffertools;
use BitWasp\Buffertools\Parser;

class Encryption
{
    const DEFAULT_SALTLEN = 10;
    const TAGLEN_BITS = 128;
    const IVLEN_BYTES = 16;

    /**
     * @param BufferInterface $pt
     * @param BufferInterface $pw
     * @return BufferInterface
     */
    public static function encrypt(BufferInterface $pt, BufferInterface $pw) {
        $salt = new Buffer(random_bytes(self::DEFAULT_SALTLEN));
        $iv = new Buffer(random_bytes(self::IVLEN_BYTES));
        $iterations = KeyDerivation::DEFAULT_ITERATIONS;
        return self::encryptWithSaltAndIV($pt, $pw, $salt, $iv, $iterations);
    }

    /**
     * @param BufferInterface $ct
     * @param BufferInterface $pw
     * @return BufferInterface
     */
    public static function decrypt(BufferInterface $ct, BufferInterface $pw) {
        $parser = new Parser($ct);
        $sLB = $parser->readBytes(1);
        $salt = $parser->readBytes($sLB->getInt());
        $itB = $parser->readBytes(4);
        $header = new Buffer($sLB->getBinary() . $salt->getBinary() . $itB->getBinary());

        $iv = $parser->readBytes(16);
        $act = $parser->readBytes($ct->getSize() - $parser->getPosition());
        $tag = $act->slice(-16);
        $ct = $act->slice(0, -16);

        return new Buffer(
            AESGCM::decrypt(
                KeyDerivation::compute($pw, $salt, unpack('V', $itB->getBinary())[1])->getBinary(),
                $iv->getBinary(),
                $ct->getBinary(),
                $header->getBinary(),
                $tag->getBinary()
            )
        );
    }

    /**
     * @param BufferInterface $pt
     * @param BufferInterface $pw
     * @param BufferInterface $salt
     * @param BufferInterface $iv
     * @param int $iterations
     * @return BufferInterface
     */
    public static function encryptWithSaltAndIV(BufferInterface $pt, BufferInterface $pw, BufferInterface $salt, BufferInterface $iv, $iterations) {
        if ($iv->getSize() !== 16) {
            throw new \RuntimeException('IV must be exactly 16 bytes');
        }

        $header = new Buffer(pack('c', $salt->getSize()) . $salt->getBinary() . pack('V', $iterations));

        list ($ct, $tag) = AESGCM::encrypt(
            KeyDerivation::compute($pw, $salt, $iterations)->getBinary(),
            $iv->getBinary(),
            $pt->getBinary(),
            $header->getBinary()
        );

        return Buffertools::concat($header, new Buffer($iv->getBinary() . $ct . $tag));
    }
}