Norbert  Ernser

Norbert Ernser

1642611240

Ce este End to End Encryption (E2EE) în tehnologia Blockchain?

În această postare, veți afla Ce este End to End Encryption (E2EE) în tehnologia Blockchain? 

Natura comunicațiilor noastre digitale de astăzi este de așa natură încât rareori comunici direct cu colegii tăi. Poate părea că tu și prietenii tăi faci schimb de mesaje în mod privat atunci când, în realitate, acestea sunt înregistrate și stocate pe un server central.

Este posibil să nu doriți ca mesajele dvs. să fie citite de serverul care este responsabil pentru trecerea lor între dvs. și destinatar. În acest caz, criptarea end-to-end (sau mai simplu, E2EE) poate fi soluția pentru tine.

Criptarea end-to-end este o metodă de criptare a comunicațiilor dintre destinatar și expeditor, astfel încât acestea să fie singurele părți care pot decripta datele. Originile sale ar putea fi urmărite încă din anii 1990, când Phil Zimmerman a lansat Pretty Good Privacy (mai bine cunoscut sub numele de PGP). 

Înainte de a înțelege de ce ați putea dori să utilizați E2EE și cum funcționează, să vedem cum funcționează mesajele necriptate.

Citiți mai multe: Ce este criptarea și cum funcționează?

Cum funcționează mesajele necriptate?

Să vorbim despre cum ar putea funcționa o platformă obișnuită de mesagerie pe smartphone. Instalați aplicația și vă creați un cont, care vă permite să comunicați cu alții care au făcut același lucru. Scrii un mesaj și introdu numele de utilizator al prietenului tău, apoi îl postezi pe un server central. Serverul vede că ați adresat mesajul prietenului dvs., așa că îl transmite la destinație. 

 

S-ar putea să știți asta ca model client-server. Clientul (telefonul tău) nu face mare lucru – în schimb, serverul se ocupă de toate sarcinile grele. Dar asta înseamnă și că furnizorul de servicii acționează ca intermediar între tine și destinatar.

De cele mai multe ori, datele dintre A <> S și S <> B din diagramă sunt criptate. Un exemplu în acest sens este Transport Layer Security (TLS), care este utilizat pe scară largă pentru a securiza conexiunile între clienți și servere.

TLS și soluțiile de securitate similare împiedică oricine să intercepteze mesajul atunci când acesta se mută de la client la server. Deși aceste măsuri pot împiedica accesul străinilor la date, serverul le poate citi în continuare. Aici intervine criptarea. Dacă datele de la A au fost criptate cu o cheie criptografică aparținând lui B , serverul nu le poate citi sau accesa. 

Fără metode E2EE, serverul poate stoca informațiile într-o bază de date alături de milioane de altele. Deoarece încălcările de date la scară largă s-au dovedit în repetate rânduri, acest lucru poate avea implicații dezastruoase pentru utilizatorii finali.

Cum funcționează criptarea end-to-end?

Criptarea de la capăt la capăt asigură că nimeni – nici măcar serverul care vă conectează cu alții – nu vă poate accesa comunicațiile. Comunicările în cauză ar putea fi orice, de la text simplu și e-mailuri la fișiere și apeluri video. 

Datele sunt criptate în aplicații precum Whatsapp, Signal sau Google Duo (se presupune), astfel încât numai expeditorii și destinatarii vizați să le poată decripta. În schemele de criptare end-to-end, ați putea începe acest proces cu ceva numit schimb de chei .

Ce este un schimb de chei Diffie-Hellman?

Ideea schimbului de chei Diffie-Hellman a fost concepută de criptografii Whitfield Diffie, Martin Hellman și Ralph Merkle. Este o tehnică puternică care permite părților să genereze un secret comun într-un mediu potențial ostil. 

Cu alte cuvinte, crearea cheii poate avea loc pe forumuri nesigure (chiar și cu privitorii care privesc) fără a compromite mesajele care urmează. În era informației, acest lucru este deosebit de valoros, deoarece părțile nu trebuie să schimbe fizic cheile pentru a comunica.

Schimbul în sine implică numere mari și magie criptografică. Nu vom intra în detalii mai fine. În schimb, vom folosi analogia populară a culorilor vopselei. Să presupunem că Alice și Bob sunt în camere de hotel separate, la capetele opuse ale unui hol și vor să împartă o anumită culoare de vopsea. Ei nu vor ca nimeni altcineva să afle despre ce este vorba.

Din păcate, podeaua este plină de spioni. Să presupunem că Alice și Bob nu pot intra unul în camerele celuilalt în acest exemplu, așa că pot interacționa doar pe hol. Ceea ce ar putea face este să cadă de acord cu o vopsea comună pe hol - să zicem, galbenă. Ei primesc o cutie din această vopsea galbenă, o împart între ei și se întorc în camerele lor respective.

În camerele lor, se vor amesteca într-o vopsea secretă - una despre care nimeni nu știe. Alice folosește o nuanță de albastru, iar Bob o nuanță de roșu. În mod crucial, spionii nu pot vedea aceste culori secrete pe care le folosesc. Totuși, vor vedea amestecurile rezultate, deoarece Alice și Bob își ies acum din camere cu preparatele lor albastru-galben și roșu-galben.

Ei schimbă aceste amestecuri în aer liber. Nu contează dacă spionii le văd acum, pentru că nu vor putea determina nuanța precisă a culorilor adăugate. Amintiți-vă că aceasta este doar o analogie - matematica reală care sta la baza acestui sistem face și mai greu de ghicit. „culoarea” secretă.

Alice ia amestecul lui Bob, Bob îl ia pe cel al lui Alice și se întorc din nou în camerele lor. Acum, își îmbină din nou culorile secrete.

  • Alice combină nuanța ei secretă de albastru cu amestecul roșu-galben al lui Bob, dând un amestec roșu-galben-albastru
  • Bob combină nuanțele sale secrete de roșu cu amestecul albastru-galben al lui Alice, dând un amestec albastru-galben-roșu

Ambele combinații au aceleași culori în ele, așa că ar trebui să arate identice. Alice și Bob au creat cu succes o culoare unică de care adversarii nu sunt conștienți.

Deci, acesta este principiul pe care îl putem folosi pentru a crea un secret comun în aer liber. Diferența este că nu avem de-a face cu holuri și vopsea, ci cu canale nesigure, chei publice și chei private.

Schimbul de mesaje

Odată ce părțile își au secretul comun, îl pot folosi ca bază pentru o schemă de criptare simetrică. Implementările populare încorporează de obicei tehnici suplimentare pentru o securitate mai robustă, dar toate acestea sunt îndepărtate de utilizator. Odată ce vă conectați cu un prieten pe o aplicație E2EE, criptarea și decriptarea pot avea loc numai pe dispozitivele dvs. (cu excepția eventualelor vulnerabilități majore ale software-ului).

Nu contează dacă ești un hacker, furnizorul de servicii sau chiar forțele de ordine. Dacă serviciul este cu adevărat criptat de la capăt la capăt, orice mesaj pe care îl interceptați va arăta ca o prostie eronată. 

Citiți mai multe: Criptare simetrică și criptare asimetrică | Tot ce trebuie să știți

Avantajele și dezavantajele criptării end-to-end

Dezavantajele criptării end-to-end

Există într-adevăr un singur dezavantaj la criptarea end-to-end - și dacă este chiar un dezavantaj depinde în întregime de perspectiva dvs. Pentru unii, propunerea de valoare a E2EE este problematică, tocmai pentru că nimeni nu vă poate accesa mesajele fără cheia corespunzătoare.

Oponenții susțin că infractorii pot folosi E2EE, în siguranță știind că guvernele și companiile de tehnologie nu își pot decripta comunicațiile. Ei cred că persoanele care respectă legea nu ar trebui să-și păstreze mesajele și apelurile telefonice secrete. Acesta este un sentiment la care au ecou mulți politicieni care susțin legislația care ar pune în spate sistemele pentru a le permite accesul la comunicații. Desigur, acest lucru ar învinge scopul criptării end-to-end.

Este de remarcat faptul că aplicațiile care folosesc E2EE nu sunt 100% sigure. Mesajele sunt ascunse atunci când sunt transmise de la un dispozitiv la altul, dar sunt vizibile la punctele terminale – adică laptopurile sau smartphone-urile de la fiecare capăt. Acesta nu este un dezavantaj al criptării end-to-end, în sine, dar merită reținut.

E2EE garantează că nimeni nu vă poate citi datele în timp ce sunt în tranzit. Dar alte amenințări mai există:

  • Dispozitivul dvs. ar putea fi furat: dacă nu aveți un cod PIN sau dacă atacatorul îl ocolește, poate obține acces la mesajele dvs.
  • Dispozitivul dvs. ar putea fi compromis: aparatul dvs. ar putea avea programe malware care spionează informațiile înainte și după ce le trimiteți.

Un alt risc este ca cineva să se intersecteze între tine și egalul tău lansând un atac de tip om-in-the-middle. Acest lucru s-ar întâmpla la începutul comunicării – dacă efectuați un schimb de chei, nu știți sigur că este cu prietenul dvs. Ai putea stabili, fără să știi, un secret cu un atacator. Atacatorul primește apoi mesajele tale și are cheia pentru a le decripta. Îți pot păcăli prietenul în același mod, ceea ce înseamnă că ar putea să transmită mesaje și să le citească sau să le modifice după cum consideră de cuviință.

Pentru a evita acest lucru, multe aplicații integrează un fel de caracteristică de cod de securitate. Acesta este un șir de numere sau un cod QR pe ​​care îl puteți partaja persoanelor de contact printr-un canal securizat (în mod ideal, offline). Dacă numerele se potrivesc, atunci puteți fi sigur că o terță parte nu vă ispită comunicările.

Avantajele criptării end-to-end

Într-o configurație fără niciuna dintre vulnerabilitățile menționate anterior, E2EE este indiscutabil o resursă foarte valoroasă pentru confidențialitate și securitate sporite. La fel ca rutarea cepei, este o tehnologie evanghelizată de activiștii de confidențialitate din întreaga lume. De asemenea, este ușor de încorporat în aplicații care seamănă cu cele cu care suntem obișnuiți, ceea ce înseamnă că tehnologia este accesibilă oricui este capabil să folosească un telefon mobil.

A privi E2EE ca pe un mecanism util doar infractorilor și avertizorilor ar fi o greșeală. Chiar și companiile aparent cele mai sigure s-au dovedit a fi susceptibile la atacuri cibernetice, expunând informațiile utilizatorilor necriptate unor părți rău intenționate. Accesul la datele utilizatorilor, cum ar fi comunicațiile sensibile sau documentele de identitate, poate avea efecte catastrofale asupra vieții persoanelor. 

Dacă o companie ai cărei utilizatori se bazează pe E2EE este încălcată, hackerii nu pot extrage nicio informație semnificativă despre conținutul mesajelor (cu condiția ca implementarea lor de criptare să fie robustă). În cel mai bun caz, ar putea obține metadate. Acest lucru este încă îngrijorător din punct de vedere al confidențialității, dar este o îmbunătățire a accesului la mesajul criptat.

Pe lângă aplicațiile menționate mai devreme, există un număr tot mai mare de instrumente E2EE disponibile gratuit. Apple iMessage și Google Duo vin la pachet cu sistemele de operare iOS și Android, iar mai mult software care ține cont de confidențialitate și securitate continuă să fie lansat.

Să reiterăm că criptarea end-to-end nu este o barieră magică împotriva tuturor formelor de atac cibernetic. Cu efort relativ mic, totuși, îl puteți folosi în mod activ pentru a reduce masiv riscul la care vă expuneți online. Alături de Tor, VPN-uri și criptomonede, mesagerii E2EE pot fi un plus valoros la arsenalul tău digital de confidențialitate.

What is GEEK

Buddha Community

Hermann  Frami

Hermann Frami

1651383480

A Simple Wrapper Around Amplify AppSync Simulator

This serverless plugin is a wrapper for amplify-appsync-simulator made for testing AppSync APIs built with serverless-appsync-plugin.

Install

npm install serverless-appsync-simulator
# or
yarn add serverless-appsync-simulator

Usage

This plugin relies on your serverless yml file and on the serverless-offline plugin.

plugins:
  - serverless-dynamodb-local # only if you need dynamodb resolvers and you don't have an external dynamodb
  - serverless-appsync-simulator
  - serverless-offline

Note: Order is important serverless-appsync-simulator must go before serverless-offline

To start the simulator, run the following command:

sls offline start

You should see in the logs something like:

...
Serverless: AppSync endpoint: http://localhost:20002/graphql
Serverless: GraphiQl: http://localhost:20002
...

Configuration

Put options under custom.appsync-simulator in your serverless.yml file

| option | default | description | | ------------------------ | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | | apiKey | 0123456789 | When using API_KEY as authentication type, the key to authenticate to the endpoint. | | port | 20002 | AppSync operations port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20002, 20012, 20022, etc.) | | wsPort | 20003 | AppSync subscriptions port; if using multiple APIs, the value of this option will be used as a starting point, and each other API will have a port of lastPort + 10 (e.g. 20003, 20013, 20023, etc.) | | location | . (base directory) | Location of the lambda functions handlers. | | refMap | {} | A mapping of resource resolutions for the Ref function | | getAttMap | {} | A mapping of resource resolutions for the GetAtt function | | importValueMap | {} | A mapping of resource resolutions for the ImportValue function | | functions | {} | A mapping of external functions for providing invoke url for external fucntions | | dynamoDb.endpoint | http://localhost:8000 | Dynamodb endpoint. Specify it if you're not using serverless-dynamodb-local. Otherwise, port is taken from dynamodb-local conf | | dynamoDb.region | localhost | Dynamodb region. Specify it if you're connecting to a remote Dynamodb intance. | | dynamoDb.accessKeyId | DEFAULT_ACCESS_KEY | AWS Access Key ID to access DynamoDB | | dynamoDb.secretAccessKey | DEFAULT_SECRET | AWS Secret Key to access DynamoDB | | dynamoDb.sessionToken | DEFAULT_ACCESS_TOKEEN | AWS Session Token to access DynamoDB, only if you have temporary security credentials configured on AWS | | dynamoDb.* | | You can add every configuration accepted by DynamoDB SDK | | rds.dbName | | Name of the database | | rds.dbHost | | Database host | | rds.dbDialect | | Database dialect. Possible values (mysql | postgres) | | rds.dbUsername | | Database username | | rds.dbPassword | | Database password | | rds.dbPort | | Database port | | watch | - *.graphql
- *.vtl | Array of glob patterns to watch for hot-reloading. |

Example:

custom:
  appsync-simulator:
    location: '.webpack/service' # use webpack build directory
    dynamoDb:
      endpoint: 'http://my-custom-dynamo:8000'

Hot-reloading

By default, the simulator will hot-relad when changes to *.graphql or *.vtl files are detected. Changes to *.yml files are not supported (yet? - this is a Serverless Framework limitation). You will need to restart the simulator each time you change yml files.

Hot-reloading relies on watchman. Make sure it is installed on your system.

You can change the files being watched with the watch option, which is then passed to watchman as the match expression.

e.g.

custom:
  appsync-simulator:
    watch:
      - ["match", "handlers/**/*.vtl", "wholename"] # => array is interpreted as the literal match expression
      - "*.graphql"                                 # => string like this is equivalent to `["match", "*.graphql"]`

Or you can opt-out by leaving an empty array or set the option to false

Note: Functions should not require hot-reloading, unless you are using a transpiler or a bundler (such as webpack, babel or typescript), un which case you should delegate hot-reloading to that instead.

Resource CloudFormation functions resolution

This plugin supports some resources resolution from the Ref, Fn::GetAtt and Fn::ImportValue functions in your yaml file. It also supports some other Cfn functions such as Fn::Join, Fb::Sub, etc.

Note: Under the hood, this features relies on the cfn-resolver-lib package. For more info on supported cfn functions, refer to the documentation

Basic usage

You can reference resources in your functions' environment variables (that will be accessible from your lambda functions) or datasource definitions. The plugin will automatically resolve them for you.

provider:
  environment:
    BUCKET_NAME:
      Ref: MyBucket # resolves to `my-bucket-name`

resources:
  Resources:
    MyDbTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: myTable
      ...
    MyBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: my-bucket-name
    ...

# in your appsync config
dataSources:
  - type: AMAZON_DYNAMODB
    name: dynamosource
    config:
      tableName:
        Ref: MyDbTable # resolves to `myTable`

Override (or mock) values

Sometimes, some references cannot be resolved, as they come from an Output from Cloudformation; or you might want to use mocked values in your local environment.

In those cases, you can define (or override) those values using the refMap, getAttMap and importValueMap options.

  • refMap takes a mapping of resource name to value pairs
  • getAttMap takes a mapping of resource name to attribute/values pairs
  • importValueMap takes a mapping of import name to values pairs

Example:

custom:
  appsync-simulator:
    refMap:
      # Override `MyDbTable` resolution from the previous example.
      MyDbTable: 'mock-myTable'
    getAttMap:
      # define ElasticSearchInstance DomainName
      ElasticSearchInstance:
        DomainEndpoint: 'localhost:9200'
    importValueMap:
      other-service-api-url: 'https://other.api.url.com/graphql'

# in your appsync config
dataSources:
  - type: AMAZON_ELASTICSEARCH
    name: elasticsource
    config:
      # endpoint resolves as 'http://localhost:9200'
      endpoint:
        Fn::Join:
          - ''
          - - https://
            - Fn::GetAtt:
                - ElasticSearchInstance
                - DomainEndpoint

Key-value mock notation

In some special cases you will need to use key-value mock nottation. Good example can be case when you need to include serverless stage value (${self:provider.stage}) in the import name.

This notation can be used with all mocks - refMap, getAttMap and importValueMap

provider:
  environment:
    FINISH_ACTIVITY_FUNCTION_ARN:
      Fn::ImportValue: other-service-api-${self:provider.stage}-url

custom:
  serverless-appsync-simulator:
    importValueMap:
      - key: other-service-api-${self:provider.stage}-url
        value: 'https://other.api.url.com/graphql'

Limitations

This plugin only tries to resolve the following parts of the yml tree:

  • provider.environment
  • functions[*].environment
  • custom.appSync

If you have the need of resolving others, feel free to open an issue and explain your use case.

For now, the supported resources to be automatically resovled by Ref: are:

  • DynamoDb tables
  • S3 Buckets

Feel free to open a PR or an issue to extend them as well.

External functions

When a function is not defined withing the current serverless file you can still call it by providing an invoke url which should point to a REST method. Make sure you specify "get" or "post" for the method. Default is "get", but you probably want "post".

custom:
  appsync-simulator:
    functions:
      addUser:
        url: http://localhost:3016/2015-03-31/functions/addUser/invocations
        method: post
      addPost:
        url: https://jsonplaceholder.typicode.com/posts
        method: post

Supported Resolver types

This plugin supports resolvers implemented by amplify-appsync-simulator, as well as custom resolvers.

From Aws Amplify:

  • NONE
  • AWS_LAMBDA
  • AMAZON_DYNAMODB
  • PIPELINE

Implemented by this plugin

  • AMAZON_ELASTIC_SEARCH
  • HTTP
  • RELATIONAL_DATABASE

Relational Database

Sample VTL for a create mutation

#set( $cols = [] )
#set( $vals = [] )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #set( $discard = $cols.add("$toSnake") )
  #if( $util.isBoolean($ctx.args.input[$entry]) )
      #if( $ctx.args.input[$entry] )
        #set( $discard = $vals.add("1") )
      #else
        #set( $discard = $vals.add("0") )
      #end
  #else
      #set( $discard = $vals.add("'$ctx.args.input[$entry]'") )
  #end
#end
#set( $valStr = $vals.toString().replace("[","(").replace("]",")") )
#set( $colStr = $cols.toString().replace("[","(").replace("]",")") )
#if ( $valStr.substring(0, 1) != '(' )
  #set( $valStr = "($valStr)" )
#end
#if ( $colStr.substring(0, 1) != '(' )
  #set( $colStr = "($colStr)" )
#end
{
  "version": "2018-05-29",
  "statements":   ["INSERT INTO <name-of-table> $colStr VALUES $valStr", "SELECT * FROM    <name-of-table> ORDER BY id DESC LIMIT 1"]
}

Sample VTL for an update mutation

#set( $update = "" )
#set( $equals = "=" )
#foreach( $entry in $ctx.args.input.keySet() )
  #set( $cur = $ctx.args.input[$entry] )
  #set( $regex = "([a-z])([A-Z]+)")
  #set( $replacement = "$1_$2")
  #set( $toSnake = $entry.replaceAll($regex, $replacement).toLowerCase() )
  #if( $util.isBoolean($cur) )
      #if( $cur )
        #set ( $cur = "1" )
      #else
        #set ( $cur = "0" )
      #end
  #end
  #if ( $util.isNullOrEmpty($update) )
      #set($update = "$toSnake$equals'$cur'" )
  #else
      #set($update = "$update,$toSnake$equals'$cur'" )
  #end
#end
{
  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> SET $update WHERE id=$ctx.args.input.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.input.id"]
}

Sample resolver for delete mutation

{
  "version": "2018-05-29",
  "statements":   ["UPDATE <name-of-table> set deleted_at=NOW() WHERE id=$ctx.args.id", "SELECT * FROM <name-of-table> WHERE id=$ctx.args.id"]
}

Sample mutation response VTL with support for handling AWSDateTime

#set ( $index = -1)
#set ( $result = $util.parseJson($ctx.result) )
#set ( $meta = $result.sqlStatementResults[1].columnMetadata)
#foreach ($column in $meta)
    #set ($index = $index + 1)
    #if ( $column["typeName"] == "timestamptz" )
        #set ($time = $result["sqlStatementResults"][1]["records"][0][$index]["stringValue"] )
        #set ( $nowEpochMillis = $util.time.parseFormattedToEpochMilliSeconds("$time.substring(0,19)+0000", "yyyy-MM-dd HH:mm:ssZ") )
        #set ( $isoDateTime = $util.time.epochMilliSecondsToISO8601($nowEpochMillis) )
        $util.qr( $result["sqlStatementResults"][1]["records"][0][$index].put("stringValue", "$isoDateTime") )
    #end
#end
#set ( $res = $util.parseJson($util.rds.toJsonString($util.toJson($result)))[1][0] )
#set ( $response = {} )
#foreach($mapKey in $res.keySet())
    #set ( $s = $mapKey.split("_") )
    #set ( $camelCase="" )
    #set ( $isFirst=true )
    #foreach($entry in $s)
        #if ( $isFirst )
          #set ( $first = $entry.substring(0,1) )
        #else
          #set ( $first = $entry.substring(0,1).toUpperCase() )
        #end
        #set ( $isFirst=false )
        #set ( $stringLength = $entry.length() )
        #set ( $remaining = $entry.substring(1, $stringLength) )
        #set ( $camelCase = "$camelCase$first$remaining" )
    #end
    $util.qr( $response.put("$camelCase", $res[$mapKey]) )
#end
$utils.toJson($response)

Using Variable Map

Variable map support is limited and does not differentiate numbers and strings data types, please inject them directly if needed.

Will be escaped properly: null, true, and false values.

{
  "version": "2018-05-29",
  "statements":   [
    "UPDATE <name-of-table> set deleted_at=NOW() WHERE id=:ID",
    "SELECT * FROM <name-of-table> WHERE id=:ID and unix_timestamp > $ctx.args.newerThan"
  ],
  variableMap: {
    ":ID": $ctx.args.id,
##    ":TIMESTAMP": $ctx.args.newerThan -- This will be handled as a string!!!
  }
}

Requires

Author: Serverless-appsync
Source Code: https://github.com/serverless-appsync/serverless-appsync-simulator 
License: MIT License

#serverless #sync #graphql 

Generis: Versatile Go Code Generator

Generis

Versatile Go code generator.

Description

Generis is a lightweight code preprocessor adding the following features to the Go language :

  • Generics.
  • Free-form macros.
  • Conditional compilation.
  • HTML templating.
  • Allman style conversion.

Sample

package main;

// -- IMPORTS

import (
    "html"
    "io"
    "log"
    "net/http"
    "net/url"
    "strconv"
    );

// -- DEFINITIONS

#define DebugMode
#as true

// ~~

#define HttpPort
#as 8080

// ~~

#define WriteLine( {{text}} )
#as log.Println( {{text}} )

// ~~

#define local {{variable}} : {{type}};
#as var {{variable}} {{type}};

// ~~

#define DeclareStack( {{type}}, {{name}} )
#as
    // -- TYPES

    type {{name}}Stack struct
    {
        ElementArray []{{type}};
    }

    // -- INQUIRIES

    func ( stack * {{name}}Stack ) IsEmpty(
        ) bool
    {
        return len( stack.ElementArray ) == 0;
    }

    // -- OPERATIONS

    func ( stack * {{name}}Stack ) Push(
        element {{type}}
        )
    {
        stack.ElementArray = append( stack.ElementArray, element );
    }

    // ~~

    func ( stack * {{name}}Stack ) Pop(
        ) {{type}}
    {
        local
            element : {{type}};

        element = stack.ElementArray[ len( stack.ElementArray ) - 1 ];

        stack.ElementArray = stack.ElementArray[ : len( stack.ElementArray ) - 1 ];

        return element;
    }
#end

// ~~

#define DeclareStack( {{type}} )
#as DeclareStack( {{type}}, {{type:PascalCase}} )

// -- TYPES

DeclareStack( string )
DeclareStack( int32 )

// -- FUNCTIONS

func HandleRootPage(
    response_writer http.ResponseWriter,
    request * http.Request
    )
{
    local
        boolean : bool;
    local
        natural : uint;
    local
        integer : int;
    local
        real : float64;
    local
        escaped_html_text,
        escaped_url_text,
        text : string;
    local
        integer_stack : Int32Stack;

    boolean = true;
    natural = 10;
    integer = 20;
    real = 30.0;
    text = "text";
    escaped_url_text = "&escaped text?";
    escaped_html_text = "<escaped text/>";

    integer_stack.Push( 10 );
    integer_stack.Push( 20 );
    integer_stack.Push( 30 );

    #write response_writer
        <!DOCTYPE html>
        <html lang="en">
            <head>
                <meta charset="utf-8">
                <title><%= request.URL.Path %></title>
            </head>
            <body>
                <% if ( boolean ) { %>
                    <%= "URL : " + request.URL.Path %>
                    <br/>
                    <%@ natural %>
                    <%# integer %>
                    <%& real %>
                    <br/>
                    <%~ text %>
                    <%^ escaped_url_text %>
                    <%= escaped_html_text %>
                    <%= "<%% ignored %%>" %>
                    <%% ignored %%>
                <% } %>
                <br/>
                Stack :
                <br/>
                <% for !integer_stack.IsEmpty() { %>
                    <%# integer_stack.Pop() %>
                <% } %>
            </body>
        </html>
    #end
}

// ~~

func main()
{
    http.HandleFunc( "/", HandleRootPage );

    #if DebugMode
        WriteLine( "Listening on http://localhost:HttpPort" );
    #end

    log.Fatal(
        http.ListenAndServe( ":HttpPort", nil )
        );
}

Syntax

#define directive

Constants and generic code can be defined with the following syntax :

#define old code
#as new code

#define old code
#as
    new
    code
#end

#define
    old
    code
#as new code

#define
    old
    code
#as
    new
    code
#end

#define parameter

The #define directive can contain one or several parameters :

{{variable name}} : hierarchical code (with properly matching brackets and parentheses)
{{variable name#}} : statement code (hierarchical code without semicolon)
{{variable name$}} : plain code
{{variable name:boolean expression}} : conditional hierarchical code
{{variable name#:boolean expression}} : conditional statement code
{{variable name$:boolean expression}} : conditional plain code

They can have a boolean expression to require they match specific conditions :

HasText text
HasPrefix prefix
HasSuffix suffix
HasIdentifier text
false
true
!expression
expression && expression
expression || expression
( expression )

The #define directive must not start or end with a parameter.

#as parameter

The #as directive can use the value of the #define parameters :

{{variable name}}
{{variable name:filter function}}
{{variable name:filter function:filter function:...}}

Their value can be changed through one or several filter functions :

LowerCase
UpperCase
MinorCase
MajorCase
SnakeCase
PascalCase
CamelCase
RemoveComments
RemoveBlanks
PackStrings
PackIdentifiers
ReplacePrefix old_prefix new_prefix
ReplaceSuffix old_suffix new_suffix
ReplaceText old_text new_text
ReplaceIdentifier old_identifier new_identifier
AddPrefix prefix
AddSuffix suffix
RemovePrefix prefix
RemoveSuffix suffix
RemoveText text
RemoveIdentifier identifier

#if directive

Conditional code can be defined with the following syntax :

#if boolean expression
    #if boolean expression
        ...
    #else
        ...
    #end
#else
    #if boolean expression
        ...
    #else
        ...
    #end
#end

The boolean expression can use the following operators :

false
true
!expression
expression && expression
expression || expression
( expression )

#write directive

Templated HTML code can be sent to a stream writer using the following syntax :

#write writer expression
    <% code %>
    <%@ natural expression %>
    <%# integer expression %>
    <%& real expression %>
    <%~ text expression %>
    <%= escaped text expression %>
    <%! removed content %>
    <%% ignored tags %%>
#end

Limitations

  • There is no operator precedence in boolean expressions.
  • The --join option requires to end the statements with a semicolon.
  • The #writer directive is only available for the Go language.

Installation

Install the DMD 2 compiler (using the MinGW setup option on Windows).

Build the executable with the following command line :

dmd -m64 generis.d

Command line

generis [options]

Options

--prefix # : set the command prefix
--parse INPUT_FOLDER/ : parse the definitions of the Generis files in the input folder
--process INPUT_FOLDER/ OUTPUT_FOLDER/ : reads the Generis files in the input folder and writes the processed files in the output folder
--trim : trim the HTML templates
--join : join the split statements
--create : create the output folders if needed
--watch : watch the Generis files for modifications
--pause 500 : time to wait before checking the Generis files again
--tabulation 4 : set the tabulation space count
--extension .go : generate files with this extension

Examples

generis --process GS/ GO/

Reads the Generis files in the GS/ folder and writes Go files in the GO/ folder.

generis --process GS/ GO/ --create

Reads the Generis files in the GS/ folder and writes Go files in the GO/ folder, creating the output folders if needed.

generis --process GS/ GO/ --create --watch

Reads the Generis files in the GS/ folder and writes Go files in the GO/ folder, creating the output folders if needed and watching the Generis files for modifications.

generis --process GS/ GO/ --trim --join --create --watch

Reads the Generis files in the GS/ folder and writes Go files in the GO/ folder, trimming the HTML templates, joining the split statements, creating the output folders if needed and watching the Generis files for modifications.

Version

2.0

Author: Senselogic
Source Code: https://github.com/senselogic/GENERIS 
License: View license

#go #golang #code 

Zoom Rolls Out End-to-End Encryption After Setbacks

Video-conferencing giant Zoom is rolling out a technical preview of its end-to-end encryption (E2EE) next week.

Zoom has faced various controversies around its encryption policies over the past year, including several lawsuits alleging that the company falsely told users that it offers full encryption. Then, the platform came under fire in May when it announced that it would indeed offer E2EE — but to paid users only. The company later backtracked after backlash from privacy advocates, who argued that security measures should be available to all. Zoom will now offer the feature to free/”Basic” users.

The first phase of the E2EE rollout aims to solicit feedback when it comes to its policies. Users will be able to weigh in during the first 30 days. Of note, users will need to turn on the feature manually (see below for details).

“We’re pleased to roll out Phase 1 of 4 of our E2EE offering, which provides robust protections to help prevent the interception of decryption keys that could be used to monitor meeting content,” said Max Krohn, head of security engineering with Zoom, in a Wednesday post.

End-To-End Encryption Errors

The topic of encryption is critical for Zoom as it ramps up its security and privacy measures – particularly after various security flaws and privacy issues exposed weaknesses in the online meeting platform, as its user base spiked during the coronavirus pandemic.

Zoom previously said that it offered E2EE, but that marketing claim came into question after a March report from The Intercept said that Zoom’s platform actually uses transport layer security (TLS) encryption, providing only encryption between individual users and service providers, instead of directly between the users of a system.

While “encryption” means that in-transit messages are encrypted, true E2EE occurs when the message is encrypted at the source user’s device, stays encrypted while its routed through servers, and then is decrypted only at the destination user’s device.

On the heels of this backlash, Zoom in May acquired a small startup called Keybase, with the aim of providing more robust encryption for Zoom calls.

In the case of next week’s rollout, Zoom’s E2EE offering will use public-key cryptography, meaning that the keys for each Zoom meeting are generated by participants’ machines (as opposed to Zoom’s servers).

#cloud security #vulnerabilities #web security #coronavirus #covid-19 #e2ee #encryption #end to end encryption #pandemic #remote work #security #transport layer security encryption #video conferencing security #zoom #zoom meeting #zoom-bombing

Devin Pinto

1606217442

Blockchain Certification | Blockchain Training Course | Blockchain Council

In all the market sectors, Blockchain technology has contributed to the redesign. The improvements that were once impossible have been pushed forward. Blockchain is one of the leading innovations with the ability to influence the various sectors of the industry. It also has the ability to be one of the career-influencing innovations at the same time. We have seen an increasing inclination towards the certification of the Blockchain in recent years, and there are obvious reasons behind it. Blockchain has everything to offer, from good packages to its universal application and futuristic development. Let’s address the reasons why one should go for Blockchain certification.

5 advantages of certification by Blockchain:

1. Lucrative packages- Everyone who completes their education or upskills themselves wants to end up with a good bundle, not only is one assured of a good learning experience with Blockchain, but the packages are drool-worthy at the same time. A Blockchain developer’s average salary varies between $150,000 and $175,000 per annum. Comparatively, a software developer gets a $137,000 per year salary. For a Blockchain developer, the San Francisco Bay area provides the highest bundle, amounting to $162,288 per annum. There’s no point arguing that learning about Blockchain is a smart decision with such lucrative packages.

2. Growing industry- When you select any qualification course, it becomes important that you choose a growing segment or industry that promises potential in the future. You should anticipate all of these with Blockchain. The size of the blockchain market is expected to rise from USD 3.0 billion in 2020 to USD 39.7 billion by 2025. This will see an incredible 67.3 percent CAGR between 2020-2025. To help business processes, several businesses are outsourcing Blockchain technologies. This clearly demonstrates that there will be higher demand in the future for Blockchain developers and certified Blockchain professionals.

3. Universal application- One of the major reasons for the success of Blockchain is that it has a global application. It is not sector-specific. Blockchain usage cases are discovered by almost all market segments. In addition, other innovations such as AI, big data, data science and much more are also supported by Blockchain. It becomes easier to get into a suitable industry once you know about Blockchain.

**4. Work protection-**Surely you would like to invest in an ability that ensures job security. You had the same chance for Blockchain. Since this is the technology of the future, understanding that Blockchain can keep up with futuristic developments will help in a successful and safe job.

**5.**After a certain point of your professional life, you are expected to learn about new abilities that can help enhance your skills. Upskilling is paramount. Upskilling oneself has become the need for the hour, and choosing a path that holds a lot of potential for the future is the best way to do this. For all computer geeks and others who want to gain awareness of emerging technology, Blockchain is a good option.

Concluding thoughts- opting for Blockchain certification is a successful career move with all these advantages. You will be able to find yourself in a safe and secured work profile once you have all the knowledge and information. Link for Blockchain certification programme with the Blockchain Council.

#blockchain certificate #blockchain training #blockchain certification #blockchain developers #blockchain #blockchain council

5 Blockchain Applications That Have Transformed the World of Technology

The blockchain is the decentralized database of the blocks of information, which gets recorded in the chain format and linked in a secured crypto graphical manner. This technology ensures proper safety of the data due to its secure nature, and it totally changes how people carry out transactions. It also brings about a faster and secure process of validating information needed to establish reliability.

Though blockchain technology came into the market to carry out only digital transactions, it is now used in various industries like supply chain, finance, health care, and many more.

The blockchain technology has made its position in mobile app development as well. Blockchain applications are transparent and accountable. From getting easy access to medical records and buying insurance, you can see blockchain applications everywhere.

Here are some of the areas where you can see the use of blockchain applications and how they have changed various industries.

1. Ripple

Ripple is useful for increasing banking transactions. The implementation of blockchain technology in the financial sector is much more profound than any other sector. Ripple proves this. It is one of the greatest tools to record and complete financial transactions.

It develops a large network despite strict physical boundaries. As there is no such third-party involvement present, the cost of these transactions is lower than usual. At the same time, the network also remains transparent and quite secured.

It is normally seen that financial transactions that happen globally are

error-prone and take a lot of time. In addition to this, when the transaction

fees and exchange rates get added up, the total cost usually gets high.

However, Ripple offers real-time international transactions without spending too much money. It has the network of about 200+ institutions making the process affordable, secure, and fast for all sorts of international transactions.

2. Etherisc

This blockchain application helps in automating flight insurance. Insurance is another area where blockchain is gaining popularity. Through this application, insurers can make smart contracts rather than getting involved in the traditional contracts that are usually complex. Etherisc is the blockchain application that helps customers buy flight insurance. If the flight gets canceled or delayed, they do not have to wait for months to get the payment back. This application ensures an on-time payout.

#blockchain #blockchain-technology #blockchain-development #blockchain-use-cases #blockchain-a #blockchain-technologies #technology #decentralization