C

Carlos-Augusto

@Carlos-Augusto·21 public vizzes

Loading thumbnail…

Gist 92ed5ad616da212ef7199f955f413567

This example shows a Java client that sends a COVID-19 vaccination certificate request to a demo certification API over HTTPS, using a custom SSL keystore for mutual authentication. It first performs a GET request to the base URL, then posts a JSON test payload containing patient and test data to the `/api/certify/v2/issue` endpoint, requesting a CBOR-encoded response. The code uses Apache HttpClient 4.5’s `CloseableHttpClient`, `HttpClients.custom()`, and `SSLContexts.custom()` with a Java KeyStore, along with `StringEntity` and `ContentType` to set the JSON body. Responses, including status lines, headers, and body text, are printed to the console.

Loading thumbnail…

Cassandra Session Connection Service

This example demonstrates a Scala implementation of a Cassandra session connection service, showing how dependency injection and lifecycle management are structured. The code defines a `ConnectionService` trait with a `CassandraStreamContext` using a `SnakeCase` naming strategy, then implements it via `DefaultConnectionService` with `@Singleton` and `@Inject` annotations. It initializes the context with a prepared statement cache size from configuration and registers a shutdown hook. The code relies on the Quill library for Cassandra streaming, TypeSafe Config for configuration, and the `Lifecycle` component for managing graceful termination.

Loading thumbnail…

Cassandra Cluster Connection Configuration

This example shows a Scala dependency-injection configuration for a Cassandra database connection, defining traits for connection services and a default implementation that creates a Cassandra stream context. The code uses `CassandraStreamContext`, `NamingStrategy`, and `SnakeCase` from the getquill library, alongside `@Inject` from `javax.inject` and `Future` for handling asynchronous shutdown hooks. It retrieves `keyspace` and `preparedStatementCacheSize` from a Typesafe `Config` object, validates the keyspace, and registers a lifecycle stop hook to close the context.

Loading thumbnail…

Cassandra Session Configuration

This example shows a Scala service that configures a Cassandra CQL session for the Ubirch accounting service. It builds a `CqlSession` via the DataStax Java driver, setting contact points, a keyspace, local datacenter, and optional consistency levels from a typesafe `Config` object. The code also demonstrates SSL context construction using Java’s `KeyStore` and `TrustManagerFactory`, plus authentication credentials when provided. Configuration paths and URL parsing come from internal Ubirch utilities, while the session builder applies programmatic driver config options like LZ4 protocol compression.

Loading thumbnail…

Cassandra Cluster Configuration

This example shows how to configure a Cassandra cluster connection using the DataStax Java driver within a Scala application. The visualization highlights the construction of a `Cluster` object through a builder pattern, setting contact points, load balancing, compression, pooling options, and query consistency levels. It also demonstrates SSL setup using `RemoteEndpointAwareJdkSSLOptions` and `KeyStore` for secure connections. The code implements a dependency-injected service (`DefaultClusterService`) that reads configuration from a Typesafe `Config`, parsing values like contact points and consistency levels via utility methods.

Loading thumbnail…

How to create a CSR for the identity service

This example generates a certificate signing request (CSR) for an identity service using an Ed25519 key pair. It demonstrates how to construct a public key with validity dates and a hardware device ID, then output the key as a string. The code uses `GeneratorKeyFactory.getPrivKey` to decode and load the private key from a Base64 string, and `PublicKeyCreationHelpers.getPublicKey2` to build the key with the specified curve, timestamps, and device identifier. The result is printed via `println` after handling success or failure through a `toTry` match.

Loading thumbnail…

Gist f902e08d16bcdf6441a5cd7d396713ca

This example shows a script that compacts JSON value-set documents from the EU Digital COVID Certificate (DCC) system by extracting active codes and their display names. It processes six files, including vaccine and test-related value sets, using JavaScript’s `require` to load each document. The code defines two functions—`getObjs` for key-value pairs and `getObjCompact` for plain codes—then iterates through the documents to push the filename, the paired object, and the compact list into an output array, which is logged via `console.log`. The script relies on the `activeStatus` flag (set to `false`) to filter entries and produces a structured JSON string for downstream use.

Loading thumbnail…

Gist d10ade16400cfea5ae8dcf371f236cd0

The example demonstrates a client-side health-check function for the Ubirch certification API, probing different deployment stages via HTTPS GET requests. It shows how to authenticate with a PFX certificate file and a hardcoded passphrase, using Node.js’s `https.Agent` with `keepAlive` enabled. The code relies on `node-fetch` for the request and `fs.readFileSync` to load the certificate, then throws errors for non-2xx status codes or empty stage names. It exports the `ping` function as a module, making it reusable across environments.

Loading thumbnail…

Gist 66c6fc93b6a8bc4bcfc82bcb4649cc11

This example demonstrates how to submit a digitally signed health certificate (HC1) to the UVE verification API using a client-side certificate for authentication. The code sends a POST request to the `https://api.uve.demo.ubirch.com/api/uve/v1/verify` endpoint, including the PFX file and passphrase in the `agentOptions` of the request library. It logs the resulting error, HTTP response, and response body to the console. The example uses the Node.js `request` module and the built-in `fs` library to read the certificate file.

Loading thumbnail…

Gist 3c568768a4a26a99f57fcfc205cdfd6c

This example demonstrates a client-side verification request for a digital health certificate, sending an encrypted payload to the Ubirch API. It shows how to authenticate with mutual TLS using a local PEM certificate and key file, then posts the certificate data as JSON. The code relies on the Node.js `request` library and the `fs` module to read the credential files, with the API endpoint configured for the `api.uve.demo.ubirch.com` host. The response body, containing the verification result, is logged to the console along with any errors.

Loading thumbnail…

Installs java lib into local maven repo

This example shows how to install a local JAR file into a Maven repository using the maven-install-plugin. It configures the plugin with the groupId, artifactId, and version for `com.cryptshare.api:cryptshare-api:5.0.0.184`, pointing to a file at `${basedir}/jars/cryptshare-api-5.0.0.184.jar`. The plugin executes its `install-file` goal during the `validate` phase, generating a POM automatically. The snippet also declares the same artifact as a dependency, demonstrating the workflow for using a library that cannot be fetched from a remote repository.

Loading thumbnail…

Gist 1b72416b70ed6ab1957e78c94a754f91

This visualization demonstrates a shell script that cleans a Git repository by removing local branches whose remote counterparts no longer exist. It shows the process of fetching all remote branches, identifying branches marked as “gone” via `git branch -vv`, and deleting them with `git branch -D`. The example uses command-line Git APIs for repository management, with output reflecting the sequential execution of these operations. The rendering approach is plain text output from the terminal, illustrating the practical workflow for tidying up stale branches after many pull requests are merged.

Loading thumbnail…

keybase

This example visualizes the trust network and cryptographic signature chain that establishes a Keybase identity proof for a GitHub user. It renders the signed JSON object, Merkle root hash, and public key fingerprint as interactive graph nodes using the Keybase API and a force-directed layout. The visualization shows how the proof binds the GitHub username to the Keybase identity, with edges representing the cryptographic relationships between the user, their gist, and the signing key. The graph layout is computed with a custom force simulation, while node details and signature data are pulled directly from the Keybase proof file.

Loading thumbnail…

Gist 22c21fedfe1389197d55288d2e2be93d

This example demonstrates a Scala implementation of HMAC-SHA256 message authentication, showing how to generate a signed hash of the string "Hello World" using a hardcoded Base64-encoded secret key. It relies on the BouncyCastle cryptographic provider, added via `Security.addProvider`, and uses the Java Cryptography Architecture's `Mac` and `SecretKeySpec` classes to initialize the HMAC with the decoded key and the "HmacSHA256" algorithm. The code processes the input bytes through `mac.update` and finally outputs the resulting MAC as a Base64-encoded string, producing a specific authentication tag.

Loading thumbnail…

Random Secret 32 bytes using Bouncy Castle

This visualization demonstrates the generation and encoding of a 33-byte random secret key using the Bouncy Castle cryptography provider in Scala. The code retrieves a secure random number generator via `SecureRandom.getInstance("DEFAULT", "BC")`, fills a byte array with `nextBytes`, and then converts the raw bytes into a Base64 string using `Base64.toBase64String`. The data source is the randomly generated key itself, with the final output being a text-based representation of the encoded secret, showcasing the provider’s integration with the Java security API.

Loading thumbnail…

Gist 89f2cb981924f2b2ad1b68db99a087af

This example demonstrates a secure HTTP POST request that sends a small JSON payload containing a message, an ID, and a timestamp to a local server endpoint. The Python script builds the request using the `requests` library, formats the data with `json.dumps` (using compact separators and sorted keys), and includes custom authentication headers (`x-pk` and `x-pass`). The server responds with an encrypted string, which the script prints alongside the original data and formatted payload for verification.

Loading thumbnail…

Gist 86a2162840809aa2b4e4890ec2ba7100

This example demonstrates how to create and validate a JSON Web Token (JWT) using the Scala library `pdi.jwt` with ES256 asymmetric encryption. It shows the complete token lifecycle: generating a key pair with `GeneratorKeyFactory` on the `PRIME256V1` curve, encoding claims (including custom fields like `role` and `env`), and finally decoding and verifying the token with the public key. The code serializes claims using `org.json4s` and `jackson.compactJson`, highlighting the interplay between JWT construction, cryptographic signing, and verification.

Loading thumbnail…

Gist c2007066af4a2f2b97d4293778f8af5d

This Scala example demonstrates a complete JWT (JSON Web Token) lifecycle, creating a signed token with custom claims and then verifying and decoding it. The code generates an ES256 key pair using `GeneratorKeyFactory` from the Ubirch crypto library, then encodes a token with `Jwt.encode` that includes tenant, device, UUID identifiers, and custom role claims, before decoding it back with `Jwt.decodeRawAll` to display the parsed header, payload, and signature. The visualized output is the `Try` result showing the extracted JSON claims alongside the cryptographic signature.

Loading thumbnail…

Gist d8122161cee20af6219aa00b744ec60e

This example decodes a JSON Web Token (JWT) in Scala, showing the three components of the token: header, payload, and signature. It uses the `pdi.jwt` library to encode a claim with a secret key and the HS256 algorithm, then decodes it back with `Jwt.decodeRawAll`. The payload contains issuer, audience, expiration, and a custom role claim, serialized via `org.json4s`.

Loading thumbnail…

Dart PointyCastle Experiment

This example demonstrates the parsing and verification of a signed data envelope encoded in base64, using Dart’s `pointycastle` cryptography library. It unpacks a binary payload with a custom `Unpacker` class, extracts the signature and signed data, and confirms they match expected base64 strings. The code then decodes an ECDSA P-256 public key and constructs an elliptic curve point from its x and y coordinates using `ECCurve_prime256v1` and `ECPublicKey`, showcasing raw key material handling and point creation without performing verification.

Loading thumbnail…

Extremist Murders in the US

This visualization compares extremist-related murders in the US over a decade, breaking down totals into right-wing extremism and white supremacist categories. It uses horizontal bars with labels and percentage annotations to show each group’s share of the overall count. The chart is built with D3 v4, using `d3.scaleLinear` for the x-axis, `d3.scaleBand` for the y-axis, and appended SVG rectangles and text elements. Data comes from an Anti-Defamation League report, and the layout mirrors a hand-drawn design by Mona Chalabi.