party | Multiplayer spatial video chat platform

It is because you are starting another server by ApplicationContext.run(EmbeddedServer.class).

You don't need it. It is enough to inject HttpClient into your class by constructor:

Option 1:

To access the raw Request and Response at the various stages of their lifecycles, use the HttpChannel.Listener (make sure you read the javadoc/apidoc to understand what each event means).

Option 2:

To add a handler in the WebAppContext, before the Session/Security handling, but after other handlers, use WebAppContext.insertHandler(HandlerWrapper).

Option 3:

Create a web-fragment servlet jar that represents your servlet Filter, and add it to the WebAppContext.setExtraClassPath(String), which will be picked up and added to the actual webapp's startup.

Option 4:

Create a custom RequestLog implementation (that you add to Server.setRequestLog(RequestLog) that is notified once the request AND response are complete, so you can log the state of the request/log to whatever source you want.

Option 5:

Use one of the existing RequestLog implementations to log the details you desire to the console in the format you desire. (Look at the combination of CustomRequestLog and Slf4jRequestLogWriter)

If this isn't going to throw an exception then I don't know what is going to.

This is caused by using blocking code within Netty's event loop.

The code over here is making a blocking request 20 times in a row which cause the machine to break. I don't know what data is coming from the client but I would never recommend to do it in this manner.

I found the solution. After the first time access was granted to my app, a new option appeared in my Google Account called "Access for untrusted third-party apps". I need to enable this option and grand access for my app again. After that my app appeared in an untrusted section of my Google Account but no access revoke by Google for now.

Ok, the signature container is embedded correctly.

But there are issues with the signature container itself:

• Both in the SignedData.digestAlgorithms collection and in the SignerInfo.digestAlgorithm value you have used the OID of SHA1withRSA, but that is a full signature algorithm, not the mere digest algorithm SHA1 expected there.

• Then the SHA1 hash of the signed bytes is BB78A402F7A537A34D6892B83881266501A691A8 but the hash you signed is 90E28B8A0D8E48691DAFE2BA10A4761FFFDCCD3D. This might be because you hash buffer2 and

  buffer2 has empty contents data (/Contents <>)

  The hex string delimiters '<' and '>' also belong to the contents value and, therefore, must also be removed in buffer2.

Furthermore, your signature is very weak:

• It uses SHA1 as hash algorithm. SHA1 meanwhile has been recognized as too weak a hash algorithm for document signatures.
• It doesn't use signed attributes, neither the ESS signing certificate nor the algorithm identifier protection attribute. Many validation policies require such special attributes.

Solution:

addContact(contact) accepts a single contact, so you would need to use for loop to add the contacts one by one.

The reason you want to change the ownership of some part of the app directory is that your app wants to modify some files or create new ones inside it at runtime. Generally speaking, it is considered a good practice to build an image to be immutable as much as possible.

Since you mentioned /app/logs, I suspect that your app generates log files while it is running. On some modern container orchestration platforms (such as Kubernetes), apps are usually designed to output logs to stdout and stderr.

The best practice is to write your application logs to the standard output (stdout) and standard error (stderr) streams.

Think about it: if your app generates logs files at /app/logs inside a container (there will be multiple containers of the same image running), how would you collect and monitor them in a unified way? What if different apps generate log files at different file system locations? But more importantly, if your container crashes, you'll just lose the log files. By writing logs to stdout and stderr, the platform will take care of all the complexities of managing and co-relating logs from all pods.

If you cannot change your app about the log files, at least you should mount a volume at /app/logs at runtime. For any container runtime (be it k8s or Docker), this is easily configurable. The mounted directory will be usually world-writable, so you won't need to change the ownership. But you'll still have to think about how to collect and manage the log files.

Likewise, if it is not for log files but that your app needs a file system to create a temporary file inside the app directory and you cannot change the location for some reason, at least you should try to mount an ephemeral volume before falling back to the last-resort of using the Jib Ownership Extension you mentioned.

Conclusively, give a careful assessment of why you have to change the ownership first. If the app wants to mutate itself at runtime, usually it's not a good practice for containerization and there must be some root cause that you may need to resolve in a proper way.

Your approach seems sound. Let me clarify some of your interrogations.

1- You are looking for a nuget but you don't need to. ATTrackingManager is part of the iOS SDK (in the AppTrackingTransparency namespace), as long as you target iOS14.5 as a compilation target you will have access to it. The Xamarin.iOS bits are built-in VisualStudio, so just make sure your version is high enough.

2- You need to add a NSUserTrackingUsageDescription in info.plist as you mentioned. This will be displayed in the popup.

3- In your code, to prompt the user with the native popup you need something like this.

You are correct that someone with access to the client_id and client_secret - and some dedication - could potentially access the resources. Do note that it also requires obtaining an authorization code from the user, which requires phishing or some other kind of - not too difficult - attack on the side. But basically impersonating the client when you have the client credentials is easy.

To prevent that, you can use techniques that are used elsewhere for keeping secrets out of the hands of rogue developers, such as:

• rotate the client secret regularly
• change the client secret explicitly on certain events, e.g. when someone leaves or a leak was detected
• use a PKI solution for client authentication (such as private_key_jwt) which does not require any changes on the Provider side to rollover the client's certificate/key, thus making the first two approaches easier (in case the client cert/key is compromised)
• use different secrets in production that in development environments and shield the secrets in production environments from people that should not have access
• etc.