3.0.9

.gitlab-ci.yml

@@ -34,6 +34,31 @@ snyk:
   - docker
   - notpriv
 
+sast:
+  stage: security
+  image: registry.gitlab.com/hosttoday/ht-docker-dbase:npmci
+  variables:
+    DOCKER_DRIVER: overlay2
+  allow_failure: true
+  services:
+    - docker:stable-dind
+  script:
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command npm run build
+    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
+    - docker run
+        --env SAST_CONFIDENCE_LEVEL="${SAST_CONFIDENCE_LEVEL:-3}"
+        --volume "$PWD:/code"
+        --volume /var/run/docker.sock:/var/run/docker.sock
+        "registry.gitlab.com/gitlab-org/security-products/sast:$SP_VERSION" /app/bin/run /code
+  artifacts:
+    reports:
+      sast: gl-sast-report.json
+  tags:
+  - docker
+  - priv
+
 # ====================
 # test stage
 # ====================

LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Push.Rocks
+Copyright (c) 2014 Maurice Butler
+Copyright (c) 2016 Lossless GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartstring",
-  "version": "3.0.5",
+  "version": "3.0.9",
   "private": false,
   "description": "handle strings in smart ways. TypeScript ready.",
   "main": "dist/index.js",
@@ -24,15 +24,17 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartstring#readme",
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.0.22",
-    "@gitzone/tsrun": "^1.1.13",
-    "@gitzone/tstest": "^1.0.15",
+    "@gitzone/tsbuild": "^2.1.4",
+    "@gitzone/tsrun": "^1.1.17",
+    "@gitzone/tstest": "^1.0.18",
     "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^10.12.10"
+    "@types/node": "^10.12.18",
+    "tslint": "^5.15.0",
+    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
     "crypto-random-string": "^1.0.0",
-    "js-base64": "^2.4.9",
+    "js-base64": "^2.5.0",
     "normalize-newline": "^3.0.0",
     "randomatic": "^3.1.1",
     "strip-indent": "^2.0.0"

test/test.normalize.ts

@@ -0,0 +1,19 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as smartstring from '../ts/index';
+
+tap.test('should normalize a string', async () => {
+  const testString = `
+    myawesome string;
+      is indented with two spaces
+  `
+  const normalizedString = smartstring.normalize.standard(testString);
+  expect(normalizedString).to.equal(
+`
+myawesome string;
+  is indented with two spaces
+  `
+  )
+})
+
+tap.start()

ts/index.ts

@@ -8,3 +8,5 @@ export { create, docker, normalize, indent };
 export { Base64, base64 } from './smartstring.base64';
 export { Domain } from './smartstring.domain';
 export { GitRepo } from './smartstring.git';
+
+export { Cryptr } from './smartstring.encryption';

ts/smartstring.create.ts

@@ -1,13 +1,29 @@
 import * as plugins from './smartstring.plugins';
 
+/**
+ * creates a random string
+ * 
+ * ```ts
+ * createRandomString('AAAA')
+ * //=> 'AGHR' 
+ * ```
+ * 
+ * @param patternArg the pattern argument to use, Aa0!* are viable pattern descritors
+ * @param lengthArg  the length of the random string
+ * @param optionsArg options
+ */
 export const createRandomString = (
   patternArg: string,
-  lengthArg: number,
-  optionsArg: any
+  lengthArg?: number,
+  optionsArg?: any
 ): string => {
   return plugins.randomatic(patternArg, lengthArg, optionsArg);
 };
 
-export const createCryptoRandomString = (lengthArg): string => {
+/**
+ * creates a crytic string in the speicifed length
+ * @param lengthArg the length of the crypto string
+ */
+export const createCryptoRandomString = (lengthArg: number): string => {
   return plugins.cryptoRandomString(lengthArg);
 };

ts/smartstring.domain.ts

@@ -1,24 +1,26 @@
 import * as plugins from './smartstring.plugins';
 
 export class Domain {
-  fullName: string;
-  level1: string;
-  level2: string;
-  level3: string;
-  level4: string;
-  level5: string;
-  protocol: string;
-  zoneName: string;
+  public fullName: string;
+  public level1: string;
+  public level2: string;
+  public level3: string;
+  public level4: string;
+  public level5: string;
+  public protocol: string;
+  public zoneName: string;
   // aliases
-  topLevel: string;
-  domainName;
-  subDomain;
+  public topLevel: string;
+  public domainName;
+  public subDomain;
+  public port;
+  public nodeParsedUrl: plugins.url.UrlWithStringQuery;
   constructor(domainStringArg: string) {
-    let regexMatches = domainRegex(domainStringArg);
+    const regexMatches = this._domainRegex(domainStringArg);
     this.fullName = '';
     for (let i = 1; i <= 5; i++) {
       if (regexMatches[i - 1]) {
-        let localMatch = regexMatches[i - 1];
+        const localMatch = regexMatches[i - 1];
         this['level' + i.toString()] = localMatch;
         if (this.fullName === '') {
           this.fullName = localMatch;
@@ -29,33 +31,50 @@ export class Domain {
         this['level' + i.toString()] = undefined;
       }
     }
-    this.protocol = protocolRegex(domainStringArg);
+    this.protocol = this._protocolRegex(domainStringArg);
     this.zoneName = this.level2 + '.' + this.level1;
 
     // aliases
     this.topLevel = this.level1;
     this.domainName = this.level2;
     this.subDomain = this.level3;
+
+    this.nodeParsedUrl = plugins.url.parse(domainStringArg);
+    this.port = this.nodeParsedUrl.port;
   }
+
+  // helper functions
+
+  /** */
+  private _domainRegex (stringArg: string) {
+    const regexString = /([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}$/;
+    const regexMatches = regexString.exec(stringArg);
+    regexMatches.reverse(); //make sure we build the domain from toplevel to subdomain (reversed order)
+    regexMatches.pop(); // pop the last element, which is, since we reversed the Array, the full String of matched elements
+    const regexMatchesFiltered = regexMatches.filter(function(stringArg: string) {
+      return stringArg !== '';
+    });
+    return regexMatchesFiltered;
+  }
+
+  private _protocolRegex (stringArg: string) {
+    const regexString = /^([a-zA-Z0-9]*):\/\//;
+    const regexMatches = regexString.exec(stringArg);
+    if (regexMatches) {
+      return regexMatches[1];
+    } else {
+      return undefined;
+    }
+  }
+
+  private _portRegex (stringArg: string) {
+    const regexString = /^([a-zA-Z0-9]*):\/\//;
+    const regexMatches = regexString.exec(stringArg);
+    if (regexMatches) {
+      return regexMatches[1];
+    } else {
+      return undefined;
+    }
+  }
+
 }
-
-let domainRegex = function(stringArg: string) {
-  let regexString = /([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}([a-zA-Z0-9\-\_]*)\.{0,1}$/;
-  let regexMatches = regexString.exec(stringArg);
-  regexMatches.reverse(); //make sure we build the domain from toplevel to subdomain (reversed order)
-  regexMatches.pop(); // pop the last element, which is, since we reversed the Array, the full String of matched elements
-  let regexMatchesFiltered = regexMatches.filter(function(stringArg: string) {
-    return stringArg !== '';
-  });
-  return regexMatchesFiltered;
-};
-
-let protocolRegex = function(stringArg: string) {
-  let regexString = /^([a-zA-Z0-9]*):\/\//;
-  let regexMatches = regexString.exec(stringArg);
-  if (regexMatches) {
-    return regexMatches[1];
-  } else {
-    return undefined;
-  }
-};

ts/smartstring.encryption.ts

@@ -0,0 +1,43 @@
+import * as plugins from './smartstring.plugins';
+
+const algorithm = 'aes-256-ctr';
+
+export class Cryptr {
+  private key: Buffer;
+
+  constructor(secret) {
+    if (!secret || typeof secret !== 'string') {
+      throw new Error('Cryptr: secret must be a non-0-length string');
+    }
+
+    this.key = plugins.crypto
+      .createHash('sha256')
+      .update(String(secret))
+      .digest();
+  }
+
+  encrypt(value: string) {
+    if (value == null) {
+      throw new Error('value must not be null or undefined');
+    }
+
+    const iv = plugins.crypto.randomBytes(16);
+    const cipher = plugins.crypto.createCipheriv(algorithm, this.key, iv);
+    const encrypted = cipher.update(String(value), 'utf8', 'hex') + cipher.final('hex');
+
+    return iv.toString('hex') + encrypted;
+  }
+
+  decrypt(value: string) {
+    if (value == null) {
+      throw new Error('value must not be null or undefined');
+    }
+
+    const stringValue = String(value);
+    const iv = Buffer.from(stringValue.slice(0, 32), 'hex');
+    const encrypted = stringValue.slice(32);
+
+    const decipher = plugins.crypto.createDecipheriv(algorithm, this.key, iv);
+    return decipher.update(encrypted, 'hex', 'utf8') + decipher.final('utf8');
+  }
+}

ts/smartstring.normalize.ts

@@ -3,11 +3,11 @@ import * as plugins from './smartstring.plugins';
 /**
  * replaces all occurences of something in a string
  * @param stringArg
- * @param searchRegExp
+ * @param searchPattern
  * @param replacementString
  */
-export const replaceAll = (stringArg: string, searchRegExp: any, replacementString: string) => {
-  return stringArg.replace(new RegExp(searchRegExp, 'g'), replacementString);
+export const replaceAll = (stringArg: string, searchPattern: string, replacementString: string) => {
+  return stringArg.replace(new RegExp(searchPattern, 'g'), replacementString);
 };
 
 /**
@@ -17,6 +17,6 @@ export const replaceAll = (stringArg: string, searchRegExp: any, replacementStri
 export const standard = (stringArg: string): string => {
   let fix1 = plugins.stripIndent(stringArg); // fix indention
   let fix2 = plugins.normalizeNewline(fix1); // fix newlines
-  let fix3 = replaceAll(fix2, /\t/, ' '); // fix tabs
+  let fix3 = replaceAll(fix2, '\t/', ' '); // fix tabs
   return fix3;
 };

ts/smartstring.plugins.ts

@@ -1,6 +1,17 @@
+// node native
+import * as crypto from 'crypto';
+import * as url from 'url';
+
+export {
+  crypto,
+  url
+};
+
+// third party
 export let jsBase64 = require('js-base64').Base64;
 
 export let stripIndent = require('strip-indent');
 export let normalizeNewline = require('normalize-newline');
 export let randomatic = require('randomatic');
 export let cryptoRandomString = require('crypto-random-string');
+