Jay Ellis and his wife, Nina Senicar, plan to welcome their second child this year. See his thoughts on being a two-time daddy.

Daddy Mode! 'Insecure' Star Jay Ellis Opens Up About Spinning The Parenthood Block With His Wife

&#x27;Insecure&#x27; star Jay Ellis spoke about soon welcoming his second baby with wife Nina Senicar during an event for his upcoming memoir &#x27;Did Everyone Have an Imaginary Friend (or Just Me?)&#x27; on June 4.

'Insecure' 's Jay Ellis ‘Terrified’ and 'Excited’ About Baby No. 2 (Exclusive)

ID Secure

idsecure

This feature is available only in (HTTPS), in some or all . Secure context secure contexts supporting browsers The Web Authentication API is an extension of the that enables strong authentication with public key cryptography, enabling passwordless authentication and/or secure second-factor authentication without SMS texts. Credential Management API Web authentication concepts and usage The Web Authentication API (also referred to as WebAuthn) uses instead of passwords or SMS texts for registering, authenticating, and with websites. This resolves significant security problems related to , , and attacks against SMS texts or other second-factor authentication methods while at the same time significantly increasing ease of use (since users don't have to manage dozens of increasingly complicated passwords). asymmetric (public-key) cryptography second-factor authentication phishing data breaches Many websites already have pages that allow users to register new accounts or sign in to an existing account, and the Web Authentication API acts as a replacement or supplement to those on those existing webpages. Similar to the other forms of the , the Web Authentication API has two basic methods that correspond to register and login: Credential Management API - when used with the publicKey option, creates new credentials, either for registering a new account or for associating a new asymmetric key pair credentials with an existing account. navigator.credentials.create() - when used with the publicKey option, uses an existing set of credentials to authenticate to a service, either logging a user in or as a form of second-factor authentication. navigator.credentials.get() both create() and get() require a (e.g. - the server is connected by https or is the localhost), and will not be available for use if the browser is not operating in a secure context. Please note: Secure Context In their most basic forms, both create() and get() receive a very large random number called a challenge from the server and they return the challenge signed by the private key back to the server. This proves to the server that a user is in possession of the private key required for authentication without revealing any secrets over the network. In order to understand how the create() and get() methods fit into the bigger picture, it is important to understand that they sit between two components that are outside the browser: - the Web Authentication API is intended to register new credentials on a server (also referred to as a service or a ) and later use those same credentials on that same server to authenticate a user. Server relying party - the credentials are created and stored in a device called an authenticator. This is a new concept in authentication: when authenticating using passwords, the password is stored in a user's brain and no other device is needed; when authenticating using web authentication, the password is replaced with a key pair that is stored in an authenticator. The authenticator may be embedded into an operating system, such as Windows Hello, or may be a physical token, such as a USB or Bluetooth Security Key. Authenticator A typical registration process has six steps, as illustrated in Figure 1 and described further below. This is a simplification of the data required for the registration process that is only intended to provide an overview. Registration The full set of required fields, optional fields, and their meanings for creating a registration request can be found in the dictionary. PublicKeyCredentialCreationOptions Likewise, the full set of response fields can be found in the interface (where is the interface). Note most JavaScript programmers that are creating an application will only really care about steps 1 and 5 where the create() function is called and subsequently returns; however, steps 2, 3, and 4 are essential to understanding the processing that takes place in the browser and authenticator and what the resulting data means. PublicKeyCredential PublicKeyCredential.response AuthenticatorAttestationResponse Figure 1 - a diagram showing the sequence of actions for a web authentication registration and the essential data associated with each action. The registration steps are: - The application makes the initial registration request. The protocol and format of this request is outside of the scope of the Web Authentication API. 1. Application Requests Registration The server sends a challenge, user information, and relying party information to the JavaScript program. The protocol for communicating with the server is not specified and is outside of the scope of the Web Authentication API. Typically, server communications would be over https (probably using or ), but they could also be , or nearly any other protocol provided that the protocol is secure. 2. Server Sends Challenge, User Info, and Relying Party Info REST XMLHttpRequest Fetch SOAP RFC 2549 The parameters received from the server will be passed to the call, typically with little or no modification and returns a that will resolve to a containing an . create() Promise PublicKeyCredential AuthenticatorAttestationResponse Note that it is absolutely critical that the challenge be a buffer of random information (at least 16 bytes) and it MUST be generated on the server in order to ensure the security of the registration process. - Internally, the browser will validate the parameters and fill in any defaults, which become the .  One of the most important parameters is the origin, which is recorded as part of the clientData so that the origin can be verified by the server later. 3. Browser Calls authenticatorMakeCredential() on Authenticator AuthenticatorResponse.clientDataJSON The parameters to the create() call are passed to the authenticator, along with a SHA-256 hash of the clientDataJSON (only a hash is sent because the link to the authenticator may be a low-bandwidth NFC or Bluetooth link and the authenticator is just going to sign over the hash to ensure that it isn't tampered with). - Before doing anything, the authenticator will typically ask for some form of user verification. This could be entering a PIN, using a fingerprint, doing an iris scan, etc. to prove that the user is present and consenting to the registration. 4. Authenticator Creates New Key Pair and Attestation After the user verification, the authenticator will create a new asymmetric key pair and safely store the private key for future reference. The public key will become part of the attestation, which the authenticator will sign over with a private key that was burned into the authenticator during its manufacturing process and that has a certificate chain that can be validated back to a root of trust. - The new public key, a globally unique credential id, and other attestation data are returned to the browser where they become the attestationObject. 5. Authenticator Returns Data to Browser - The create() Promise resolves to an , which has a that is the globally unique credential id along with a response that is the containing the and . 6. Browser Creates Final Data, Application sends response to Server PublicKeyCredential PublicKeyCredential.rawId AuthenticatorAttestationResponse AuthenticatorResponse.clientDataJSON AuthenticatorAttestationResponse.attestationObject The is sent back to the server using any desired formatting and protocol (note that the ArrayBuffer properties need to be be base64 encoded or similar). PublicKeyCredential - Finally, the server is required to perform a series of checks to ensure that the registration was complete and not tampered with. These include: 7. Server Validates and Finalizes Registration Verifying that the challenge is the same as the challenge that was sent Ensuring that the origin was the origin expected Validating that the signature over the clientDataHash and the attestation using the certificate chain for that specific model of the authenticator A complete list of validation steps . Assuming that the checks pan out, the server will store the new public key associated with the user's account for future use -- that is, whenever the user desires to use the public key for authentication. After a user has registered with web authentication, they can subsequently authenticate (a.k.a. - login or sign-in) with the service. The authentication flow looks similar to the registration flow, and the illustration of actions in Figure 2 may be recognizable as being similar to the illustration of registration actions in Figure 1. can be found in the Web Authentication API specification Authentication The primary differences between registration and authentication are that: 1) authentication doesn't require user or relying party information; and 2) authentication creates an assertion using the previously generated key pair for the service rather than creating an attestation with the key pair that was burned into the authenticator during manufacturing. Again, the description of authentication below is a broad overview rather than getting into all the options and features of the Web Authentication API. The specific options for authenticating can be found in the dictionary, and the resulting data can be found in the interface (where is the interface) . PublicKeyCredentialRequestOptions PublicKeyCredential PublicKeyCredential.response AuthenticatorAssertionResponse Figure 2 - similar to Figure 1, a diagram showing the sequence of actions for a web authentication and the essential data associated with each action. - The application makes the initial authentication request. The protocol and format of this request is outside of the scope of the Web Authentication API. 1. Application Requests Authentication - The server sends a challenge to the JavaScript program. The protocol for communicating with the server is not specified and is outside of the scope of the Web Authentication API. Typically, server communications would be over https (probably using or ), but they could also be , or nearly any other protocol provided that the protocol is secure. The parameters received from the server will be passed to the call, typically with little or no modification. 2. Server Sends Challenge REST XMLHttpRequest Fetch SOAP RFC 2549 get() Note that it is absolutely critical that the challenge be a buffer of random information (at least 16 bytes) and it MUST be generated on the server in order to ensure the security of the authentication process. - Internally, the browser will validate the parameters and fill in any defaults, which become the . One of the most important parameters is the origin, which recorded as part of the clientData so that the origin can be verified by the server later. 3. Browser Calls authenticatorGetCredential() on Authenticator AuthenticatorResponse.clientDataJSON The parameters to the get() call are passed to the authenticator, along with a SHA-256 hash of the clientDataJSON (only a hash is sent because the link to the authenticator may be a low-bandwidth NFC or Bluetooth link and the authenticator is just going to sign over the hash to ensure that it isn't tampered with). - The authenticator finds a credential for this service that matches the Relying Party ID and prompts a user to consent to the authentication. Assuming both of those steps are successful, the authenticator will create a new assertion by signing over the clientDataHash and authenticatorData with the private key generated for this account during the registration call. 4. Authenticator Creates an Assertion - The authenticator returns the authenticatorData and assertion signature back to the browser. 5. Authenticator Returns Data to Browser - The browser resolves the to a with a that contains the . 6. Browser Creates Final Data, Application sends response to Server Promise PublicKeyCredential PublicKeyCredential.response AuthenticatorAssertionResponse It is up to the JavaScript application to transmit this data back to the server using any protocol and format of its choice. - Upon receiving the result of the authentication request, the server performs validation of the response such as: 7. Server Validates and Finalizes Authentication Using the public key that was stored during the registration request to validate the signature by the authenticator. Ensuring that the challenge that was signed by the authenticator matches the challenge that was generated by the server. Checking that the Relying Party ID is the one expected for this service. A full list of the . Assuming the validation is successful, the server will note that the user is now authenticated. This is outside the scope of the Web Authentication API specification, but one option would be to drop a new cookie for the user session. steps for validating an assertion can be found in the Web Authentication API specification Interfaces Credential Provides information about an entity as a prerequisite to a trust decision. CredentialsContainer Exposes methods to request credentials and notify the user agent when events such as successful sign in or sign out happen. This interface is accessible from . The Web Authentication specification adds a member to the and methods to either create a new public key pair or get an authentication for a key pair, repsectively. Navigator.credentials publicKey create() get() PublicKeyCredential Provides information about a public key / private key pair, which is a credential for logging in to a service using an un-phishable and data-breach resistant asymmetric key pair instead of a password. AuthenticatorResponse The base interface for and , which provide a cryptographic root of trust for a key pair. Returned by and , respectively, the child interfaces include information from the browser such as the challenge origin. Either may be returned from . AuthenticatorAttestationResponse AuthenticatorAssertionResponse CredentialsContainer.create() CredentialsContainer.get() PublicKeyCredential.response AuthenticatorAttestationResponse Returned by when a is passed, and provides a cryptographic root of trust for the new key pair that has been generated. CredentialsContainer.create() PublicKeyCredential AuthenticatorAssertionResponse Returned by when a is passed, and provides proof to a service that it has a key pair and that the authentication request is valid and approved. CredentialsContainer.get() PublicKeyCredential Options PublicKeyCredentialCreationOptions The options passed to . CredentialsContainer.create() PublicKeyCredentialRequestOptions The options passed to . CredentialsContainer.get() Examples For security reasons, web authentication calls ( and ) are cancelled if the browser window loses focus while the call is pending. create() get() createCredentialDefaultArgs = { : { rp: { : }, user: { : ( ), : , : }, : [{ : , : }], : , : , : ([ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]).buffer
    }
}; getCredentialDefaultArgs = { : { : , challenge: ([ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]).buffer
    },
}; navigator.credentials.create(createCredentialDefaultArgs)
    .then( { .log( , cred); idList = [{ : cred.rawId, : [ , , ], : }];
        getCredentialDefaultArgs.publicKey.allowCredentials = idList; navigator.credentials.get(getCredentialDefaultArgs);
    })
    .then( { .log( , assertion);
    })
    .catch( { .log( , err);
    }); // sample arguments for registration var publicKey // Relying Party (a.k.a. - Service): name "Acme" // User: id new Uint8Array 16 name "john.p.smith@example.com" displayName "John P. Smith" pubKeyCredParams type "public-key" alg -7 attestation "direct" timeout 60000 challenge new Uint8Array // must be a cryptographically random number sent from a server 0x8C 0x0A 0x26 0xFF 0x22 0x91 0xC1 0xE9 0xB9 0x4E 0x2E 0x17 0x1A 0x98 0x6A 0x73 0x71 0x9D 0x43 0x48 0xD5 0xA7 0x6A 0x15 0x7E 0x38 0x94 0x52 0x77 0x97 0x0F 0xEF // sample arguments for login var publicKey timeout 60000 // allowCredentials: [newCredential] // see below new Uint8Array // must be a cryptographically random number sent from a server 0x79 0x50 0x68 0x71 0xDA 0xEE 0xEE 0xB9 0x94 0xC3 0xC2 0x15 0x67 0x65 0x26 0x22 0xE3 0xF3 0xAB 0x3B 0x78 0x2E 0xD5 0x6F 0x81 0x26 0xE2 0xA6 0x01 0x7D 0x74 0x50 // register / create a new credential ( ) => cred console "NEW CREDENTIAL" // normally the credential IDs available for an account would come from a server // but we can just copy them from above... var id transports "usb" "nfc" "ble" type "public-key" return ( ) => assertion console "ASSERTION" ( ) => err console "ERROR" website and its . Mozilla Demo source code website and its . Google Demo source code and its and webauthn.org client source code server source code Specifications Browser compatibility CredentialsContainer.create See also , ( 2FA) is an additional layer of security you can add to your login page. WordPress Two-Factor Authentication WordPress Credits Source: https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API Published under licence Open CC Attribution ShareAlike 3.0

Web Auth Standard: Guide to Web Authentication API 

I was trying to create my first actual microservice program and very soon I faced an issue: "How many times I should do the authentication?" In the first part, I describe the situation and in the second part, I show how should we configure the express gateway to perform the jwt authentication and pass the claims in the request to the service endpoints. Feel free to skip the first part and go straight to the second part. And if you only want the express-gateway jwt part, go to at the end of the article, there is a complete config which could be used. Adding the authenticated data to the request Problem statement! I was going to use jwt token authentication for users. I had 2 microservices, one for user authentication (sign up, sign in, sign out) and one for CURD operations on a model, we call them auth-service and curd-service. I started writing code, and developed the auth-service, as you know jwt uses a key to deal with the tokens (create them or verify them). Everything worked fine until I started to develop the curd-service. I needed to authenticate the user in the request before performing the desired curd-service operation, but how? When the request (let say GET entered the system, it didn't necessarily go through the auth-service, and it probably contains the jwt token in the header. If I wanted to verify and decrypt the token in the crud-service I needed the secure-key in the crud-service. It instantly raised the question of whether I should put the secure-key in the curd-service or not? What if there are many services which may be at the front line of a system, do all of them need to have access to the " "-key? I started to look for a solution, I wasn't the first person who had more than one service in his system. I found very good articles and learned a lot. /books/:_id) secure https://medium.com/technology-learning/how-we-solved-authentication-and-authorization-in-our-microservice-architecture-994539d1b6e6 https://stackoverflow.com/questions/49836268/how-to-deal-with-authentication-in-a-micro-services-architecture Long story short, one of the solutions is to have an API gateway, so every request goes through it. Adding an API gateway to your architecture has many benefits, it can perform rate limiting, request logging, acting as a proxy, handing CORS and also authenticating the requests. Although like anything else in life, it comes with its drawbacks, it can become a bottleneck or a single point of failure in the whole system. Anyway, I decided to use an API gateway as seemed (and still does) like a very good solution. By using API gateway, we can perform the authentication at the API gateway and only put the secret-key at the API gateway (besides the auth-service itself). I started looking for an API gateway and decided to go with . Express-Gateway Configuring Express Gateway for jwt Authentication The documentation on the Express Gateway is pretty neat and you can find almost anything where it should be. Here we are going to configure the express gateway to add the decoded authentication data ( jwt claims) to the request before passing it to our other services. As is mentioned in the , it supports different ways for handling the jwt token in the request. Here I use the default way which is having header with keyword. express gateway docs Authorization Bearer 1. Starting Point To be on the same page, let's say we have an auth-service which performs login and register under and on the host . We also have a curd-service for books which all start with and they are served at . /auth/register /auth/login auth:3003 /books books:4004 We need the api gateway to handle different requests. and need to be logged, and passed to as these request are not authenticated and thats the reason they are talking to . But for requests matching the gateway needs to make sure they are authenticated (contain a valid token) and also decrypt the token and add its content to the request before handing the request to . /auth/register /auth/login auth-service auth-service /books* curd-service 2. Create a new express gateway This is the same as it is mentioned on docs. a. Install Express Gateway npm install -g express-gateway b. Create an Express Gateway $ eg gateway create c. Answer a few questions ➜ eg gateway create
 ? What is the name of your Express Gateway? my-gateway
 ? Where would you like to install your Express Gateway? my-gateway
 ? What of Express Gateway you want to create? (Use arrow keys)
 ❯ Getting Started with Express Gateway
   Basic (default pipeline with proxy) type do d. For running it, go to the folder and run npm start 3. Configure the gateway to log and proxy the requests After creating a new express gateway it generates a pretty complete and runnable template for us which only needs to be configured. All of the configuration we need to do are at the . It also supports hot-reloading, so you don't need to restart the express gateway every time you change something in the config files. /config/gateway.config.yml I'm not going into details of how to configure express gateway because as I mentioned before the documentation is fine. I just mention the core concepts and also suggest that you read the docs. There are a few core concepts at express gateway, represent the endpoint of incoming requests (the ones system's users are sending, , and in our example). represent where the requests should be redirected to ( , in our example). are actually telling the express gateway how to handle the requests. tell the express gateway which tools we are going to use in the pipelines section (logging, authentication and proxy in our example). apiEndpoints /auth/register /auth/login /books* serviceEndpoints auth:3003 books:4004 pipelines principles We first define the log and proxy for /auth* Here we are telling the express gateway to listen to port 9080 for incoming requests, if they match the pattern and their HTTP method is POST, log them and redirect them to . Please note there is no authentication happening here. /auth* http://auth:3003 4. Authenticate and adding the authenticated data to the request If the requests contain a token which is generated using a secret-key, express gateway can authenticate and decrypt the token (assuming we provide it the same key) and put the authenticated data in the . We further need to add to the request before passing it to the desired serviceEndpoint. req.user req.user http: port: 9080 admin: port: 9876 host: localhost apiEndpoints: auth: path: '/auth*' methods: ['POST'] serviceEndpoints: auth: url: 'http://auth:3003' policies: - log - proxy pipelines: authPipeline: apiEndpoints: - auth policies: - log: action: message: 'auth ${req.method}' - proxy: action: serviceEndpoint: auth Please notice that you need to update the section too. And just adding the new , and is not enough. policies serviceEndpoint apiEndpoint pipeline http: port: 9080 admin: port: 9876 host: localhost apiEndpoints: auth: path: '/auth*' methods: ['POST'] books: path: '/books*' serviceEndpoints: auth: url: 'http://auth:3003' books: url: 'http://books:4004' policies: - log - proxy - jwt - request-transformer pipelines: authPipeline: apiEndpoints: - auth policies: - log: action: message: 'auth ${req.method}' - proxy: action: serviceEndpoint: auth booksPipeline: apiEndpoints: - books policies: - log: action: message: 'books ${req.method}' - jwt: action: secretOrPublicKey: 'the-secret-key' checkCredentialExistence: false - request-transformer: action: body: add: user: req.user - proxy: action: serviceEndpoint: books the new pipeline (booksPipeline) is performing the proxying and logging action in the same way authEndpoint performs it. The difference is that  we are using two new policies. and . jwt request-transformer JWT is in charge of authenticating the jwt token in the header, by default it tries to locate it in the header but it's possible to define other approaches using the and properties. If express gateway doesn't find a valid token it responds to the request with a 401 error, which is great as the request won't enter the system and there is 1 less request needs to be worry about. specifies the secret-key, we could also use the . jwt Authorization jwtExtractor jwtExtractorField curd-service secretOrPublicKey secretOrPublicKeyFile By setting the as we are telling the express gateway we want it in the mode, you can read about this . Briefly, it is saying that we create and manage the tokens in another service (express gateway has the option to create the tokens through its admin API with ) checkCredentialExistence false Uncontrolled modality here Controlled Modality As the name suggests transforms the request by adding or removing different values to its header or body. If you don't add this to your pipeline, the decoded information from the token won't be available to the serviceEndpoint in which express gateway redirects the requests. This is a intentional and a secure behavior, we don't want anything to be added to or removed from our request without us knowing. request-transformer request-transformer 5. What comes next? Now, when the request enters the we are sure it's authenticated and it contains the decoded information of the token (user id, role, ....) in the . You would also have the jwt token unchanged, if you wish to remove it from the request for any reason (maybe security), you can do it by another policy which can also remove stuff. curd-service req.user request-transformer I hope this has been useful, I'd be glad to get any feedback.

Authentication Middleware in Express Gateway using JWT

In the late 2010s, “the data rush” ushered businesses to collect as much user data as possible in the high hopes of making their products, marketing and sales processes more effective. While some companies have seen major successes from their ramped up data collection and analytics, not everyone ended up . being a winner In 2016, McKinsey estimated that of the data generated up to date was being analyzed. Perhaps, we can assume that with the latest advances in BI tools and big data analytics that number could have ticked to 5% or perhaps even 10%. only 1% Still, 90% of data lakes remain untouched. What's even more important is that a lot of that data can never be put into action. In most industries, personally identifiable information (PII) is off-limits for analysis, though Cambridge Analytica definitely taught us of the opposite. However, collecting, exchanging and securely storing this type of data has become a legal responsibility for businesses across industries. A very costly responsibility. Since 2011, the cost of compliance , reaching $5.47 billion in 2017. Technology, albeit helpful, has also played a major role in heightening the compliance costs, specifically those associated with IT infrastructure, cybersecurity and data privacy. increased by 45% Last year, British companies spent over on GDPR preparation, with their US counterparts allocating over $7.8 billion for the same matter. For 90% of the businesses, , GDPR is the most challenging data regulation to meet. PCI DSS, US State Laws and HIPAA/HiTech are coming in at a close second. $1.1 billion cumulatively surveyed by Global Scale All of these regulations have one thing in common: they urge businesses to respect users’ privacy, anonymity and consent to share or withhold certain information. The best, though least straightforward, way to achieve this demand may be letting go of customers’ data and switching to a new paradigm of thinking – self-sovereign identities (SSI). What is SSI In the offline realm, we have plenty of ways to share different attributes about ourselves without an intermediary to back up the claims we are making. Showing a photo ID is usually enough to prove that you are who you say you are. Thus, most societal interactions are scalable, flexible and private. However, what is self-identity in the digital space? At present, it’s a compilation of online personas that hundreds of organizations store. One’s digital identity does not exist independently from those systems. Third parties are also required to orchestrate and authenticate a transaction. When signing up for a new credit card online, you may be asked to provide a picture of your ID document, your social security number and/or other sensitive data that is operationalized by a KYC provider before being transmitted to the bank. Once the process is done, it becomes the , stored in their systems. bank’s responsibility to digitally protect your identity data emerged as a new paradigm suggesting that identity owners (users) should be placed in the center of their personal data ecosystem. The sovereignty definition, in this case, is that users have sole ownership of their digital and analog identities and can moderate how their personal data is shared and used by third-parties. Self-sovereign identity (SSI) What SSI system promises is to ‘place the ID back into your wallet' instead of the bank's on-premises systems. All the personal credentials will be stored on the blockchain and only certain attributes about the identity owner will be shared with a party requesting access to them. For instance, an HR manager will be able to request permission to access the applicant’s university data, provided by the educational institution, but at the same time, will not be able to inquire about your citizenship status without your explicit consent. To be viable, , : SSI systems should be based on the next 10 guiding principles proposed by Christopher Allen – Users must have an independent existence. What self-sovereign identity does is making some aspects of the person’s identity public and accessible. Existence – Users must control their identities, i.e. act as the ultimate authority. They should be able to update, refer to it or even hide it according to their wishes. Control – Users must have access to their data and have a mechanism to retrieve all the claims associated with their identity. Access – Systems and algorithms must be transparent. Ideally free, open-sources and fully independent of any particular architecture, so that anyone could examine how they work. Transparency – Identities must be long-lived. They should last for as long as the user wishes. Persistence – Information and services about identity must be transportable. No single third-party entity must hold that data. Portability – Identities should be as widely usable as possible, and become globally recognized at some point. Interoperability – Users must agree to the use of their identity. Any data shared is a subject of consent from the user. Consent – Disclosure of claims must be minimized. Only the necessary minimum amount of data should be provided to fulfil the claim. Minimization – The rights of users must be protected. The system should always lean towards protecting the users’ rights and remain censorship-resistant and force-resilient. Protection In short, the main idea behind the self-sovereign identity is to transfer the control over personal data back to the users, reducing the burden of data management and security risks for business as well. What Data Management Challenges SSIs Can Address? from Evernym has perfectly summarized the current set of problems with online identities and personal data management: Andy Tobin – users’ identity information is highly fragmented and stored in silos around the Internet and by different organizations. Current single sign-on (SSO) solutions or federated identities, enabling users to sign on to another service using an existing account on Google, Twitter and Facebook only partially address the issue of interoperability. However, they do not always make it easier to ensure that you are dealing with the right type of person. The proximity problem – the landscape is dominated by Centralized ID providers (i.e., Google, Facebook and Twitter dominate the social login landscape). Some businesses are wary about granting access to their customer information to a 3rd party provider, due to the enforcement of compliance standards, liability, monopolization and security risks. The scale problem – are fragmented and rigid, limiting the potential use cases. The flexibility problem current identity solutions – personal identifiers are often collected without the user’s knowledge, and afterwards replicated across a variety of systems. The proves that centralized storage of sensitive customer data is not viable. The privacy problem recent wave of data breaches – sensitive information, buried in the thousands of identity silos, is often distributed to other parties without the owner's explicit permission or knowledge. The consent problem As a result, some customers' have found themselves with the shorter end of the stick – improved convenience achieved by giving away control over their personal identifiers and other identity-related information. Businesses, in turn, are pressured to over-rely on selected few IDPs and SSO providers, who control large amounts of data. Organizations, who are required to store sensitive data locally, are as well pressured by the increased compliance demands. Self-sovereign systems, based on blockchain, have recently emerged as a strong contender to solve the data management conundrum. Introducing a universal, decentralized digital identity layer can help establish a new ecosystem of digital interactions with independent actors (self-sovereign individuals) granting access to their personal data, stored on an immutable decentralized ledger, to a 3rd party requesting trustworthy identification. From a technological standpoint, such self-sovereign identity blockchain systems will operate on two distinct levels as . Kai Wagner suggests an individual or organization controls a certain credential and its uses. Credential-based roles: – an individual or entity that a given credential is about. In this context: we are the subjects of our passports, bank accounts, or social media profiles. Subject – an individual or entity that stores and fully controls the use of a given credential. For instance, you can be a holder of your own digital passport, as well as your children's. Holder – an individual or entity who provided a credential in the first place. It could be the government or your university. Issuer – the individual or entity who verifies or relies upon a presented credential. Verifier an individual or entity who owns and/or controls certain DIDs and their uses. This is a unique key, granted to any type of data online, that remains under full control of the Identity Owner, and is not dependent on a centralized authority or identity provider. Decentralized identifier roles: – an individual or entity that can be identified by a given DID. DID Subject – the individual or entity who stores and controls the private keys associated with that DID. In other words, the one who's granting permission to access certain data. DID Owner (or Identity Owner) Let's give this model more context with another example: you need to digitally prove to someone that you live where you say you live. However, you need another entity to attest your claim, for instance, a utility provider or a governmental authority. They can provide you with some form of (a fresh utility bill). Once you receive that bill, you become the Holder of that Credential. You can present a self-attested claim (your statement about where you live), paired with a Verifiable Credential issued and cryptographically signed by the utility services provider, meaning that it's an authentic document. Now, your opponent (the Verifier) can ensure the legitimacy of your claim. Or they may request another verification document from an Issuer (a governmental body) to cross-check the information. In any case, you as the Holder will always remain present in the interaction, and grant control to the requested information, using cryptographic signatures. credential The particular draw here is that none of the participants needs to create a new digital identity for the user or store sensitive data locally. Every piece of data and transaction information is kept in a decentralized network, simplifying data management and compliance. Source: Blockchain Bundesverband As a result, businesses can gain several major advantages by adopting self-sovereign identity systems: : SSI-powered apps are ready for immediate use. No data syncs are required or extended onboarding. Users can start using the system once they receive their credentials. Speed : SSI credentials, stored on blockchain, are cross-app, cross-border, cross-silo and can be leveraged for different use cases. Interoperability : Blockchain is nearly impossible to tamper, meaning that only the true owner can have access to their credentials. Security : SSI can be a major step towards "privacy by design", as personal identifiers never change hands. Identity owners store their information in secure wallets (not on the ledger) and can grant access to their data to 3rd parties when requested. This can majorly reduce the data storage and compliance costs for businesses, especially in regards to GDPR. Privacy Industries That Will Benefit The Most From SSI Industries with the tightest KYC procedures (banking, insurance, healthcare) will be among the prime benefitters. Though, self-sovereign identity introduction can turn the tables for virtually any business dealing with customer data in one way or another: – a Spanish non-profit blockchain consortium is developing a national blockchain ecosystem for the country that would help with the identification of natural and legal persons in the country. The State of Illinois has to create a pilot of blockchain-based birth registry. And last year, the government of British Columbia and Ontario in Canada issued representing business registrations and licenses for businesses as part of their blockchain pilots. Public services and government management: Alastria signed up a partnership agreement with Evernym over 6 million self-sovereign credentials Civic startup is working on a reusable KYC solution and for storing personal identity information, fiat money, and crypto-assets that could be securely used cross-merchant. The company also offers . EVRY and Infopulse together developed an SSI solution that can be leveraged by e-commerce companies instead of standard authentication apps and payment gateways. This 1-click-pay mobile payment solution, for instance, requires just 8 taps to complete a transaction versus 160+ taps that an average user now needs to make. A good example when the convenience does not come at a cost of personal data exposure. Retail: blockchain wallet age-verification technology for vending machines Seattle-based startup is building an SSI identification management system on Sovrin, aimed at securing access to patient records. Instead of creating new online identities for patients, healthcare institutions can request access to patient status and medical data, securely hashed into a  12-digit code and recorded on the blockchain. Healthcare services: iRespond Introduction of SSI can majorly streamline the KYC process for banks, reduce fraud levels and minimize the compliance costs. This year, released a new blockchain-based user identification, allowing customers to prove who they are using the information they've already given to their financial institution. To improve customer service and risk management, EVRY in cooperation with Infopulse developed that makes a complete audit trail helping banks with regulatory compliance and reduction of data validation costs across the whole financial network. Banking: five Canadian banks blockchain-based KYC banking system Final Thoughts To conclude, self-sovereign systems enable businesses to securely validate who they are dealing with and eliminate the need for any 3rd-party KYC providers. Instead, a decentralized, neutral blockchain ledger can perform the role of the verifier. Personally identifiable information will remain in the hands of users, reducing the compliance, cybersecurity and data management costs. As a result, we could enter the new age of scalable, flexible and private interactions online, performed with the user's consent.

Self-Sovereign Identity Systems: How Businesses Win From Letting Go of Customers’ Data

Whether it is fake reviews that mislead consumers and harm businesses, fake user activity that defrauds advertisers, or fake news that is used to manipulate elections and markets, fakery is pervasive on the internet. The scale is massive and the economic and social impacts are profound. Fakery and Fraud on a Massive Scale Jupiter Research estimates that marketing fraud will cost advertisers $19 Billion Dollars in 2018. ( ) https://www.raconteur.net/risk-management/tackle-marketing-fraud It is estimated that over half of all web traffic is from bots. ( ) https://www.theatlantic.com/technology/archive/2017/01/bots-bots-bots/515043/ Facebook detected and deleted 583 Million fake accounts in just the first quarter of 2018, but they estimate that Tens of Millions remain. ( ) https://www.cnet.com/news/facebook-deleted-583-million-fake-accounts-in-the-first-three-months-of-2018/ Twitter recently deleted Tens of Millions of fake accounts, roughly 6% of their user base, in what is only their most recent clean up of fraudulent accounts. ( ) https://www.nytimes.com/2018/07/11/technology/twitter-fake-followers.html The Washington Post found that for some popular categories of products on Amazon the vast majority of reviews are fraudulent.( ) https://www.washingtonpost.com/business/economy/how-merchants-secretly-use-facebook-to-flood-amazon-with-fake-reviews/2018/04/23/5dad1e30-4392-11e8-8569-26fda6b404c7_story.html And of course there are the infamous Russian Bots. ( ) ( ) https://www.salon.com/2018/07/09/russian-bots-are-back-walkaway-attack-on-democrats-is-a-likely-kremlin-operation/ https://www.nbcnews.com/tech/social-media/russian-trolls-pushed-graphic-racist-tweets-american-voters-n823001 Fake and fraudulent activity on the internet is resulting in direct losses of Tens of Billions of Dollars per year. There are Hundreds of Billions of Dollars of purchasing decisions per year being manipulated by fake reviews. Both businesses and consumers pay the price for all this fraud and the magnitude is so great that ultimately the entire economy is impacted. The social costs of illegal political propaganda, or what might be called information warfare, are impossible to quantify but the threat that this activity poses is even greater than that of simple profit motivated fraud. Digital Real IDs The concept of a Real ID is simple: in order to make a post on Facebook, write a review on Amazon, log in to your bank account, or send an email you have to authenticate yourself with an ID that is registered with your real name and issued through a secure process equivalent in nature to the issue of a Driver’s License or State Identification Card. Digital In practice there are two deal-breaking objections to Digital Real IDs: Such a system is technically impossible to implement Anonymity is a basic right that must not be infringed If it is assumed that anonymity or pseudonymity must be part of the system, to the extent that these are protected legal rights, the only real challenge is to design a Digital Real ID system that actually works, while still allowing for anonymity in the contexts where it is a protected right. Many people say that such a system is impossible, but that answer is simply not acceptable in the face of the enormous economic costs and threat to civil society posed by digital fakery and fraud. A Digital Real ID system that protects anonymity is not only possible but necessary. Building the Foundation The foundation of a Digital Real ID system must be built into computers, mobile devices, and network infrastructure at the hardware level. Each Digital ID must be implemented as a physical device, similar to a SIM card, or USB dongle, that can be easily swapped between different devices. Each Digital ID device incorporates a simple computer processor that is limited to receiving a message from the host device, signing that message with a digital signature, and then sending the message back to the host device. Each Digital ID device has a unique digital signature that is implemented in the device hardware and is impossible to change. Every device that connects to the internet must have a network chip that requires a Digital ID device to be present in order to operate and every single packet of data sent by the network chip must be digitally signed by the Digital ID device. Networking infrastructure hardware must be designed to read and verify the digital signatures on each data packet and must prevent any data packet without a valid digital signature from being transmitted. With this foundation in place every single packet of data that transits the internet can be positively and indisputably associated with a particular Digital ID. A Digital ID by itself is still anonymous or pseudonymous. In order to turn an anonymous Digital ID into a Digital Real ID rules, processes, and systems to associated Digital IDs with Real IDs must be established. Managing Digital Real IDs The hardware infrastructure that associates data sent over the internet to individual Digital IDs is independent from the system that associates those Digital IDs with Real IDs. This allows the same hardware to be used globally while allowing local jurisdictions to establish their own Real ID registries and set their own rules for what types of online activity require Real IDs. While the details can vary between jurisdictions each jurisdiction maintains its own registry associating Digital IDs with Real IDs and/or maintains a list of registries that are trusted and used. A Real ID registry would allow individuals to establish a Real ID by providing an existing government issued ID in person and associating that Real ID with one or more Digital IDs. As long as an individual is using an authorized Digital ID device they can add and remove Digital IDs from their Real ID profile online. If a Real ID profile is compromised or an individual loses all of their Digital ID devices then they would need to go to a registry in person to re-establish access to their Real ID profile and register a new Digital ID. Requiring Digital Real IDs Digital Real IDs could be required at the network level in certain cases to completely prevent unverified data from transiting secure networks. In other cases Digital Real IDs could be required at the application level. At the application level a Digital Real ID would work similar to existing third party authentication systems such as the buttons that allow you to sign in to an account with Google or Facebook. At the application level a website would send a token to the Digital ID device and the Digital ID device would return this token with a digital signature. The application would then contact the Real ID registry and present the signed token in order to get the user’s Real ID. The use of Digital IDs and Digital Real IDs would provide a single universal login system that would eliminate the need for users to manage usernames, passwords, and personal profiles for individual web sites and applications. What Problems do Digital Real IDs Solve? Requiring Digital Real IDs for social media posts and product reviews would eliminate the vast majority of fakery and fraud currently taking place online whether that be for financial gain or political purposes. Even if a service does not require Real IDs, Digital IDs could still be leveraged to reduce fraud by introducing significantly higher costs for creating unique online accounts. Marketing fraud relies on fake user activity, which must be faked very cheaply, so introducing Digital IDs that cost even a few dollars each would make most fraudulent schemes unprofitable. Economically motivated fraud can always be eliminated by making it unprofitable and so the cost of Digital IDs can be adjusted through taxation to whatever level is needed to make the majority of fraud unprofitable. Digital Real IDs will dramatically improve for users by locking down their online accounts. Unlike existing two-factor authentication systems, Digital Real IDs provide a secure mechanism to recover access to accounts when Digital ID devices are lost or stolen. security The use of Digital IDs at the network level gives users the ability to manage their network traffic in a new way by setting rules for what domains or IP addresses their Digital ID device will issue signatures for. Through this mechanism Digital ID devices can act as an out-of-band firewall that cannot be hacked or bypassed even when used with compromised host hardware. A Digital ID device is very simple and thus much easier to audit and secure than a modern computer or mobile device, which is essentially impossible to audit or secure. Requiring all internet traffic to be signed by a Digital ID device would put users back in control of their own computers and mobile devices by giving them the ability to monitor and optionally block every packet of data sent by their device over the network. In the event that a Digital ID device was bypassed, such as by a compromised network chip, a user operating their own network could trivially detect and block such compromises by using networking hardware that only allowed traffic signed by an allowed set of Digital IDs. Roadmap for Digital Real IDs Building the infrastructure foundation for Digital IDs could be done by the private sector on their own initiative but it would progress much faster if a major government mandated it. Realistically, either the U.S., E.U. or China would need to develop the hardware specification and mandate it for hardware sold in their market in order for implementation to be insured. Once one major market makes Digital IDs a requirement it would probably be implemented in all new hardware and the private sector in other markets would include it voluntarily. Requiring Digital IDs at the internet backbone level, setting up Digital Real ID registries, and requiring certain online services to use Digital Real IDs can all be done incrementally on a jurisdiction-by-jurisdiction basis once Digital ID support is baked into new hardware. Everyone stands to benefit from the use of Digital IDs and Digital Real IDs including individuals, businesses and governments. Digital IDs can be leveraged to eliminate Tens of Billions of Dollars in yearly fraud. Digital Real IDs can shift social media from being an existential threat to civil society to being the powerful enabler of civil society that technologists had hoped and dreamed it would be. Anonymity or pseudonymity can be maintained as rights with the long established limitation that those rights do not extend to committing crimes or harming others. These rights will be subject to a small tax, which prevents them from being abused for petty fraud, but that is an entirely reasonable price to pay. After many years of failing to act it is time for tech companies and leaders to stop claiming that Digital Real IDs are impossible or infringe on individual rights and start getting to work on implementing them. Ultimately, changes in law are needed, but the private sector will benefit greatly from being the leader rather than the follower in this process. Stay tuned for part two: Strong End-to-End Encryption with Authorized Access for Law Enforcement is Possible and Necessary

Digital Real IDs that Preserve Anonymity are Possible and Necessary

Simple math Here at , we’ve decided to put at the center of our solution because it’s such a versatile component in the world and we want to tell you a bit about how we use it. Coneuron S3 serverless AWS But before we get into our explanation, let me tell you a bit about myself, the journey I took, and how S3 is related to it. Deep inside I am a software developer, over the past 12 years in the software industry, I was dealing mainly with backend and mobile development, up until last year most of my work was done in server-more environment, a bit of S3, RDS and the only time I used lambda was as part of my Python code. I joined a startup called a year ago as head of engineering. As a father of twins, the startup’s mission was very compelling: . These are three simple words, but pose a huge problem technically and product wise. Coneuron reduce negativity online As a small startup, we have decided right from the start that we prefer to go serverless, for the sole reason that we prefer to concentrate on our product and not on provisioning a linux machine. Going serverless is more than using Lambdas or FaaS; it’s a state of mind where you “outsource” everything that is not core to your business. (But what is serverless in my own mind is a different post. Let’s move forward.) How does S3 fit into the picture? Before answering that, you need to understand how Coneuron works. We collect data (a lot of it), which our users share in various social networks. Data is collected on a mobile device and one of our earliest problems was the question of, “How do we upload this data into our system in order to analyze it?”. We wanted the solution to support the following futures: Uploaded data can weigh from 1K up to several hundreds Ks (and in some cases even a couple of megabytes) and each device can upload content hundreds of times a day. We live in a FaaS world, and I want the solution to play nicely with what we already have, e.g. Lambda. From a security perspective, we want to try to minimize the attack surface of the interface. We want to be able to save content for future use (debugging, replaying, reanalyzing, etc.) High level view We use S3 as a simple queue where no order is guaranteed. Everything starts with a single device. Here’s how it works: On the device itself we compress all data; reducing size is mandatory both for saving space on S3 and reducing the used bandwidth on device. These compressed files are saved in our S3 bucket enabling us to better debug, fine tune our ML algorithms, and duplicate our production environment data in one click. forever, Instead of a single API that and , we’ve separated the process into two steps: Coneuron uses an internal authentication service (more on that in future posts), which on a given token produces a . This pre-signed url is time restricted and after X amount of time it expires. In addition it allows us to control how the resulting file name will look like. The file name itself represents which user uploaded the file. We use [unique_id]_[human_readable_id]_[time]_[uuid] to represent a file that a user uploaded. This url is used by a device to produce a simple post request and upload the file to an S3 bucket. authenticates enables the end point to upload a file — pre-signed post url — Pay attention that Coneuron’s service is not handling the actual upload; it only produces the url for upload. This technique has another benefit of the ability to run A/B testing quite easily. There’s no need to push any flags to the device in order to use a different url. All you have to do is just to give a different pre-signed url, a different bucket and a different piece of code is ran. The last part in the process is a Lambda function attached to the S3 bucket. Using S3 prefix/suffix triggers, we are able to run the right Lambda depending on file type (more on that later). It was good × 2 We like the architecture above. It proved to work very well so we’ve decided to stretch it a bit and use S3 + Lambda as a for our internal services. S3 acts as a non-ordered queue, and each service that we have in the system creates a message and saves it into a predefined folder with specific suffix. A Lambda catches the event, and according to the suffix of the file, forwards it to the correct service. Saving all API interactions in S3 greatly improves debugging, and there’s no need to look at logs in order to view the arguments/parameters etc. Just pick the json file containing the interaction, view it in , or replay it on your machine with break points. In addition, we can leverage our knowledge in S3 without introducing any new service into the system. messaging gateway your preferred editor Implementation details Folder structure for S3 based queue IS3 bucket event configuration All messages arrive to a single folder named and multiple Lambda functions are configured to listen to different file names. (You can configure it under → tab.) Each file with a different suffix represents a different service. When a message is processed successfully it is being moved to an folder. As I wrote earlier, we keep all messages forever. incoming events properties analyzed All of our messages are POPO (plain old python objects) that implement two main methods: Save — This will serialize the message into json and save it in to a S3 folder with specific suffix. Pay attention that each serialized message in addition to the content itself contains versioning and date. For example: {"meta": {"version": 1,"date": "2018–07–01 10:41:58.925570+00:00"},"user_id": 944,"sent_to_id": 365} from_stream — This will read the actual serialized file, verify its validity, and convert it to POPO. Saving a message triggers the Lambda that is attached to the S3 bucket and the message is read. A common functionality is shared by all services: details <- get file details from eventactual_file <- download file from S3 to local storagedo_magic() move file to done folder in case of an error move to dead letter bucket # implemented by the service itself # save forever Like any messaging system, we have a dead letter bucket. The bucket contains all messages that for some reason failed analyze successfully. By using a scheduled Lambda task that runs once per hour, we move all messages back to the folder and try to reanalyze them. In distributed systems things fail once in a while, but usually retrying the same message again will succeed. We do track using internal metrics the number of messages that we retried in order to pinpoint real bugs. incoming Summary S3 is a versatile . Its basic nature of storage elasticity combined with powerful API and Lambda integration gives it super powers. I’ve demonstrated two possible usages: tool Easy and secure file uploads from various clients → a kind of API GW Messaging system You are more than welcome to share your experience with S3 and how you extended it beyond its original purpose. Read “from the trenches” series Serverless testing from the trenches Serverless multi-cloud from the trenches Development flow in serverless environment from the trenches — Follow me to get an update when it’s ready

S3 the best of 2 worlds

Crypto Tool or Data Thief? How Meme-Token-Hunter-Bot and Its Clones Steal from macOS Users

ክሪፕቶ መሣሪያ ወይስ ዳታ ሌባ? Meme-Token-Hunter-Bot እና ክሎኖቹ ከማክሮስ ተጠቃሚዎች እንዴት እንደሚሰርቁ

¿Herramienta criptográfica o ladrón de datos? Cómo el Meme-Token-Hunter-Bot y sus clones roban a los usuarios de macOS

כלי קריפטו או גנב נתונים? כיצד Meme-Token-Hunter-Bot והשיבוטים שלו גונבים ממשתמשי macOS

暗号ツールかデータ泥棒か？Meme-Token-Hunter-BotとそのクローンがmacOSユーザーから盗む方法

Крипто алатка или крадец на податоци? Како Meme-Token-Hunter-Bot и неговите клонови крадат од корисниците на macOS

Alat Kripto atau Pencuri Data? Bagaimana Meme-Token-Hunter-Bot dan Klonnya Mencuri daripada Pengguna macOS

د کریپټو وسیله یا ډیټا چور؟ څنګه Meme-Token-Hunter-Bot او د هغې کلونونه د macOS کاروونکو څخه غلا کوي

¿Cripto Herramientachu icha Datos Suwachu? Imaynatachus Meme-Token-Hunter-Bot chaymanta Clonesnin macOS Usuariokunamanta suwakunku

Kryptoverktyg eller datatjuv? Hur Meme-Token-Hunter-Bot och dess kloner stjäl från macOS-användare

Асбоби крипто ё дузди маълумот? Чӣ тавр Meme-Token-Hunter-Bot ва клонҳои он аз корбарони macOS медузданд

Kripto Aracı mı yoksa Veri Hırsızı mı? Meme-Token-Hunter-Bot ve Klonları macOS Kullanıcılarından Nasıl Çalıyor?

Ithuluzi le-Crypto noma Isela Ledatha? Indlela i-Meme-Token-Hunter-Bot nama-Clones ayo antshontsha ngayo kubasebenzisi be-macOS

Trader Loses $26M in ezETH Tokens: Media Blames User, Hacker Calls Out ERC-20 Flaws

Trader mister $26M i ezETH-tokens: Media Blames User, Hacker Call Out ERC-20 Flaws

Un comerciante pierde 26 millones de dólares en tokens ezETH: los medios culpan al usuario y un pirata informático denuncia las fallas de ERC-20

Machann pèdi $ 26M nan ezETH Tokens: Medya blame itilizatè, Hacker rele defo ERC-20

トレーダーが ezETH トークンで 2,600 万ドルを失う: メディアはユーザーを非難、ハッカーは ERC-20 の欠陥を指摘

ពាណិជ្ជករបាត់បង់ 26 លានដុល្លារនៅក្នុង ezETH Tokens: ប្រព័ន្ធផ្សព្វផ្សាយបន្ទោសអ្នកប្រើប្រាស់, Hacker ហៅកំហុស ERC-20

Prekybininkas praranda 26 mln. USD ezETH žetonų: žiniasklaida kaltina vartotoją, įsilaužėlis praneša apie ERC-20 trūkumus

व्यापारीले ezETH टोकनहरूमा $ 26M गुमायो: मिडियाले प्रयोगकर्तालाई दोष दिन्छ, ह्याकरले ERC-20 त्रुटिहरू बोलाउँछ

Comerciante $26M ezETH Tokens kaqpi chinkachin: Medios de comunicación Usuariota huchachan, Hacker ERC-20 pantaykunata waqyan

Mutengesi Anorasikirwa nemadhora 26M mu ezETH Tokens: Media Inopomera Mushandisi, Hacker Anodaidza ERC-20 Makanganiso

Trader förlorar 26 miljoner dollar i ezETH-tokens: Media skyller på användare, hackare kallar ut ERC-20-brister

Treyder ezETH tokenlarida 26 million dollar yo‘qotdi: OAV foydalanuvchini ayblaydi, xaker ERC-20 kamchiliklarini chaqiradi

Umrhwebi Ulahlekelwa yi-26M yeedola kwiiMpawu ze-EZETH: I-Media Blames User, i-Hacker ibiza i-ERC-20 iimpazamo

Java Backend Observability with OpenTelemetry Traces and Minimal Code

ওপেনটেলিমেট্রি ট্রেস এবং ন্যূনতম কোড সহ জাভা ব্যাকএন্ড পর্যবেক্ষণযোগ্যতা

Java-Backend-Beobachtbarkeit mit OpenTelemetry Traces und minimalem Code

Observabilidad del backend de Java con trazas de OpenTelemetry y código mínimo

Observabilité du backend Java avec les traces OpenTelemetry et le code minimal

ओपनटेलीमेट्री ट्रेसेस और न्यूनतम कोड के साथ जावा बैकएंड अवलोकनीयता

OpenTelemetry トレースと最小限のコードによる Java バックエンドの可観測性

OpenTelemetry 추적 및 최소 코드를 사용한 Java 백엔드 관찰성

Observabilidade do backend Java com OpenTelemetry Traces e código mínimo

Наблюдаемость Java Backend с помощью трассировок OpenTelemetry и минимального кода

OpenTelemetri İzleri ve Minimal Kod ile Java Arka Uç Gözlemlenebilirliği

Khả năng quan sát Java Backend với OpenTelemetry Traces và mã tối thiểu

使用 OpenTelemetry Traces 和最少代码实现 Java 后端可观察性

7 Unspoken Rules of BYOD Security in the Workplace

 How To Implement IP Rotation With Proxies

Cómo implementar la rotación de IP con servidores proxy

 Nola ezarri IP biraketa proxiekin

प्रॉक्सी के साथ आईपी रोटेशन कैसे लागू करें

 Kako implementirati IP rotaciju s proxyjima

プロキシを使用して IP ローテーションを実装する方法

 Ndenge Nini Ko mettre en œuvre Rotation IP Na ba Proxy

 Kā ieviest IP rotāciju ar starpniekserveriem

 Cara Melaksanakan Putaran IP Dengan Proksi

 د پراکسي سره د IP گردش څنګه پلي کول

Как реализовать ротацию IP-адресов с помощью прокси-серверов

 Ndlela Yo Tirhisa IP Rotation Hi Ti Proxies

 Proksi-serverlar yordamida IP aylanishini qanday amalga oshirish mumkin

Stories, News & Mentions about IDSECURE

Idsecure’s Stories on HackerNoon

Idsecure's News & Mentions