@iotize/tap
Version:
IoTize Device client for Javascript
337 lines • 30.2 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { bufferToHexString } from '@iotize/common/byte-converter';
import { AesEcb128Converter } from '@iotize/common/crypto';
import { deepCopy } from '@iotize/common/utility';
import { ServiceCallRunner, TapError, TapResponse, TapResponseStatusError, } from '@iotize/tap';
import { ResultCode, } from '@iotize/tap/client/api';
import { CryptedFrameConverter, TapClientError, TapRequestHelper, TapStreamWriter, } from '@iotize/tap/client/impl';
import { ScramService, } from '@iotize/tap/service/impl/scram';
import { defer, throwError } from 'rxjs';
import { map, mergeMap, tap as rxTap, shareReplay } from 'rxjs/operators';
import { debug } from './debug';
import { TapScramError } from './scram-errors';
const INITIALIZATION_VECTOR_LENGTH = 16;
const DEFAULT_INITIALIZATION_VECTOR = '00000000000000000000000000000000';
const TAG = 'ScramInterceptor';
function _hex(data) {
return data ? bufferToHexString(data) : '';
}
export class ScramInterceptor {
constructor(scramService) {
this.scramService = scramService;
this._ivFrameCounter = 0;
this._ivSupported = true;
this._options = {
encryption: false,
initializationVectorResetPeriod: 100,
keys: {},
frameCounter: 0,
};
this._encryptedFrameConverter = new CryptedFrameConverter({
next: () => {
return this._options.frameCounter++;
},
});
this.initializationVectorGenerator = (length) => {
const data = new Array(length).fill(0).map((_) => {
return Math.floor(Math.random() * 0xff);
});
return Uint8Array.from(data);
};
}
get encryptionAlgo() {
if (!this._encryptionAlgo) {
throw TapClientError.illegalStateError(`Encryption algo has not been set yet`);
}
return this._encryptionAlgo;
}
set ivSupported(v) {
this._ivSupported = v;
}
/**
* Setter for the session key
* @param key if null, it will stop encryption and remove session key. If true it will update session key used for encryption
*/
set sessionKey(key) {
this._options.keys.sessionKey = key;
this._options.frameCounter = 0;
if (this._options.keys.sessionKey) {
this.refreshEncryptionAlgo();
}
else {
this.pauseEncryption();
}
}
get sessionKey() {
return this._options.keys.sessionKey;
}
/**
* Get a copy of encryption options
*/
get options() {
return deepCopy(this._options);
}
setEncryptionKeys(options) {
this._options.keys = options;
this.refreshEncryptionAlgo();
}
getEncryptionKeys() {
return this._options.keys;
}
setFrameCounter(value) {
this._options.frameCounter = value;
}
setInitializationVectorRefreshPeriod(period) {
this._options.initializationVectorResetPeriod = period;
}
intercept(context, next) {
const request = context.request;
debug(TAG, `exec ${TapRequestHelper.toString(request)} (encryption:${this._options.encryption}, frameCounter: ${this._options.frameCounter} - skip ${context.skipEncryption}, key: ${_hex(this.sessionKey)} iv decode: ${_hex(this._options.keys.ivDecode)}, iv encode: ${_hex(this._options.keys.ivEncode)})`);
let obs;
if (this._options.encryption && !context.skipEncryption) {
obs = this._sendWithEncryption(context, next).pipe(map((response) => {
const data = response.rawBody();
return {
status: response.status,
data,
};
}));
}
else {
obs = next.handle(context);
}
return obs.pipe(rxTap((response) => {
debug(TAG, `Response to ${TapRequestHelper.toString(request)} => ${response.status} ${bufferToHexString(response.data)}`);
}));
}
_sendWithEncryption(context, next) {
if (!this._encryptedFrameConverter) {
return throwError(TapClientError.illegalStateError(`Encrypted frame converter has not been specified yet`));
}
let callObs;
let newClientIV;
if (this._options.initializationVectorResetPeriod === 1) {
newClientIV = this.initializationVectorGenerator(INITIALIZATION_VECTOR_LENGTH);
this._setEncodeIV(newClientIV);
debug(TAG, `Changing initialization vector for every requests. New client IV: ${_hex(newClientIV)}`);
const cryptedFrame = this._buildEncryptedFrame(context);
const call = this.scramService.sendWithIVCall({
request: cryptedFrame,
iv: newClientIV,
});
callObs = this._toCallObservable(Object.assign(Object.assign({}, context), { skipEncryption: true }), next, call).pipe(map((response) => {
// if (response.isSuccessful() && response.rawBody().length < INITIALIZATION_VECTOR_LENGTH){
// // tap firmware version is too old apparentl.
// // CCOM IV resource was already used to generate rand number before firmware version 1.83, thats why there is a success code result
// throw TapError.initializationVectorNotSupported(
// new Error(`Tap response is too short`)
// );
// }
const body = response.body();
debug(TAG, `Refreshing decoding initialization vector: ${_hex(body.iv)}`);
this._setDecodeIV(body.iv);
return TapResponse.create(response.status, body.response);
}));
}
else {
if (this._options.initializationVectorResetPeriod > 1 &&
this._ivFrameCounter >= this._options.initializationVectorResetPeriod &&
!isRefreshInitializationVectorRequest(context.request)) {
debug(TAG, `_ivInterceptor refreshEncryptionInitializationVector is required ${this._ivFrameCounter}/${this._options.initializationVectorResetPeriod}`);
if (!this._refreshingInitializationVectorObs) {
this._refreshingInitializationVectorObs = defer(() => __awaiter(this, void 0, void 0, function* () {
try {
return yield this.refreshInitializationVectors();
}
finally {
this._refreshingInitializationVectorObs = undefined;
}
})).pipe(shareReplay({ bufferSize: 1, refCount: true }));
}
else {
// debug(TAG, `Refreshing initialization vector has already been asked`);
}
callObs = this._refreshingInitializationVectorObs.pipe(mergeMap((_) => {
const encryptedFrame = this._buildEncryptedFrame(context);
return this._toCallObservable(context, next, this.scramService.sendCall(encryptedFrame));
}));
}
else {
const encryptedFrame = this._buildEncryptedFrame(context);
const call = this.scramService.sendCall(encryptedFrame);
callObs = this._toCallObservable(context, next, call);
}
}
return callObs.pipe(map((encryptedWarpperResponse) => {
this._ivFrameCounter++;
// debug(TAG, `Iotize client crypted frame: ${encryptedWarpperResponse}`);
if (!encryptedWarpperResponse.isSuccessful()) {
if (encryptedWarpperResponse.codeRet() ===
ResultCode.SERVICE_UNAVAILABLE) {
throw TapScramError.scramNotStartedYet(context.request);
}
else if (encryptedWarpperResponse.codeRet() === ResultCode.BAD_REQUEST) {
throw TapScramError.invalidScramKey(context.request);
}
encryptedWarpperResponse.successful();
}
const cryptedFrameContent = this.encryptionAlgo.decode(encryptedWarpperResponse.rawBody());
// debug(TAG, `Decrypted frame value: ${_hex(cryptedFrameContent)}`);
const apduFrame = this._encryptedFrameConverter.decode(cryptedFrameContent);
// debug(TAG, `apduFrame frame value: ${_hex(apduFrame)}`);
const tapResponse = context.client.responseDecoder.decode(apduFrame);
const apiResponse = new TapResponse(tapResponse, context.request);
// let response: TapResponse<any> = this.lwm2mResponseConverter.decode(lwm2mResponseFrame.data);
if (context.bodyDecoder) {
apiResponse.setBodyDecoder(context.bodyDecoder);
}
// debug(TAG, `Iotize client decoded response: ${response}`)
return apiResponse;
}));
}
_buildEncryptedFrame(context) {
const iotizeFrame = TapStreamWriter.create(10 + context.request.payload.length).writeTapRequestFrame(context.request).toBytes;
const encryptedFrameModel = this._encryptedFrameConverter.encode(iotizeFrame);
const encryptedFrame = this.encryptionAlgo.encode(encryptedFrameModel);
return encryptedFrame;
}
_setEncodeIV(iv) {
this._options.keys.ivEncode = iv;
this.refreshEncryptionAlgo();
}
_setDecodeIV(iv) {
this._options.keys.ivDecode = iv;
this.refreshEncryptionAlgo();
}
_toCallObservable(context, next, call) {
const tapRequest = ServiceCallRunner.toTapRequest(call);
const bodyDecoderFct = ServiceCallRunner.resolveResponseBodyDecoder(call);
const bodyDecoder = bodyDecoderFct
? {
decode: bodyDecoderFct,
}
: undefined;
return next
.handle(Object.assign(Object.assign({}, context), { request: tapRequest, bodyDecoder }))
.pipe(map((tapResponse) => {
return new TapResponse(tapResponse, context.request, bodyDecoder);
}));
}
/**
* Refresh initialization vectors
*/
refreshInitializationVectors() {
return __awaiter(this, void 0, void 0, function* () {
const clientIV = this.initializationVectorGenerator(INITIALIZATION_VECTOR_LENGTH);
try {
debug(TAG, `Performing initialization vector refresh`);
const serverIV = (yield this.scramService.setInitializationVector(clientIV)).body();
this._options.keys.ivEncode = clientIV;
this._options.keys.ivDecode = serverIV;
this._ivFrameCounter = 0;
debug(TAG, `Initialization vector refreshed: server ${_hex(serverIV)} client=${_hex(clientIV)})`);
this.refreshEncryptionAlgo();
}
catch (err) {
debug(TAG, `Cannot refresh initialization vector: ${err.message}`);
if (err instanceof TapResponseStatusError) {
const tapResponseStatus = err.response.status;
if (tapResponseStatus === ResultCode.NOT_IMPLEMENTED ||
tapResponseStatus === ResultCode.NOT_FOUND) {
debug(TAG, `Cannot initialize encryption vectors (firmware version does not support it). Error: ${err.message}`);
this._ivSupported = false;
throw TapError.initializationVectorNotSupported(err);
}
}
throw err;
}
});
}
/**
* Resume encryption session
*/
resumeEncryption() {
debug(TAG, `resume encryption`);
this._options.encryption = true;
}
/**
* Pause encryption without destorying session (session keys will not be removed)
*/
pauseEncryption() {
debug(TAG, `pause encryption`);
this._options.encryption = false;
}
/**
* Initialize a new encrypted sesssion
* Session key will be changed. Initialization vector too (if firmware supports it)
*/
newSession() {
return __awaiter(this, void 0, void 0, function* () {
try {
debug(TAG, `Creating new encryption session`);
this.clearSession();
const response = yield this.scramService.initialize();
response.successful();
const newSessionKey = response.body();
this.sessionKey = newSessionKey;
debug(TAG, `Session key will be ${_hex(newSessionKey)} (length=${newSessionKey.length})`);
if (this._options.initializationVectorResetPeriod > 0) {
try {
yield this.refreshInitializationVectors();
}
catch (err) {
// Ignore initialization vector not supported error
if (err.code !==
TapError.Code.InitializationVectorNotSupported) {
throw err;
}
}
}
return newSessionKey;
}
catch (err) {
throw TapError.cannotStartScram(err);
}
});
}
/**
* Clear encrypted session.
* Destroys frame counter, session keys and initialization vectors
* This will also stop encrypted communication if it was running
*/
clearSession() {
this.pauseEncryption();
this._options.keys.ivDecode = undefined;
this._options.keys.ivEncode = undefined;
this._options.keys.sessionKey = undefined;
this._ivFrameCounter = 0;
}
refreshEncryptionAlgo() {
if (this._options.keys.sessionKey) {
const algo = new AesEcb128Converter({
key: _hex(this._options.keys.sessionKey),
ivDecode: this._options.keys.ivDecode
? _hex(this._options.keys.ivDecode)
: DEFAULT_INITIALIZATION_VECTOR,
ivEncode: this._options.keys.ivEncode
? _hex(this._options.keys.ivEncode)
: DEFAULT_INITIALIZATION_VECTOR,
});
this._encryptionAlgo = algo;
}
}
}
const SCRAM_CALL_FACTORY = new ScramService(undefined);
function isRefreshInitializationVectorRequest(request) {
return (TapRequestHelper.pathToString(request.header.path) ===
SCRAM_CALL_FACTORY.resources.setInitializationVector.path);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scram-interceptor.js","sourceRoot":"","sources":["../../../../../../auth/src/lib/scram-interceptor.ts"],"names":[],"mappings":"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"}