Page MenuHomePhabricator
Differential D12202

[native] update `olm` API to allow creating session without OTKs
ClosedPublic
Actions

Authored by kamil on May 23 2024, 4:20 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Mar 12, 1:18 PM
Unknown Object (File)
Thu, Mar 6, 10:24 PM
Unknown Object (File)
Thu, Mar 6, 6:01 AM
Unknown Object (File)
Wed, Mar 5, 2:04 PM
Unknown Object (File)
Wed, Mar 5, 3:56 AM
Unknown Object (File)
Feb 21 2025, 12:42 AM
Unknown Object (File)
Feb 21 2025, 12:42 AM
Unknown Object (File)
Feb 21 2025, 12:42 AM
View All 70 Files
Subscribers
ashoat

Details

Reviewers
marcin
tomek
Commits
rCOMM84ed5f6bbfd4: [native] update `olm` API to allow creating session without OTKs
Summary

Modifying CryptoModule API.

Depends on D12201

Test Plan

Tested in D12204.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
CryptoTools/
2 lines
2 lines
3 lines
30 lines
NativeModules/
4 lines
35 lines
_generated/
schema/
4 lines

Diff 40830

View Options

native/cpp/CommonCpp/CryptoTools/CryptoModule.h

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/CryptoTools/Session.h

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/CryptoTools/Session.cpp

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

pub mod error; pub mod error;
pub mod identity; pub mod identity;
pub mod tunnelbroker; pub mod tunnelbroker;
// Re-export some dependencies which may need to be used by downstream crates // Re-export some dependencies which may need to be used by downstream crates
pub use tonic; pub use tonic;
use error::Error; use error::Error;
use std::path::Path;
use std::time::Duration; use std::time::Duration;
use tonic::transport::{Certificate, Channel, ClientTlsConfig}; use tonic::transport::Channel;
use tracing::info; use tracing::info;
const CERT_PATHS: &[&str] = &[
// MacOS and newer Ubuntu
"/etc/ssl/cert.pem",
// Common CA cert paths
"/etc/ssl/certs/ca-bundle.crt",
"/etc/ssl/certs/ca-certificates.crt",
];
const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
pub(crate) fn get_ca_cert_contents() -> Option<String> {
CERT_PATHS
.iter()
.map(Path::new)
.filter(|p| p.exists())
.filter_map(|f| std::fs::read_to_string(f).ok())
.next()
}
pub(crate) async fn get_grpc_service_channel( pub(crate) async fn get_grpc_service_channel(
url: &str, url: &str,
) -> Result<Channel, Error> { ) -> Result<Channel, Error> {
let ca_cert = crate::get_ca_cert_contents().expect("Unable to get CA bundle");
info!("Connecting to gRPC service at {}", url); info!("Connecting to gRPC service at {}", url);
let mut channel = Channel::from_shared(url.to_string())? let channel = Channel::from_shared(url.to_string())?
.connect_timeout(CONNECT_TIMEOUT_DURATION); .connect_timeout(CONNECT_TIMEOUT_DURATION);
// tls_config will fail if the underlying URI is only http://
if url.starts_with("https:") {
channel = channel.tls_config(
ClientTlsConfig::new().ca_certificate(Certificate::from_pem(&ca_cert)),
)?
}
Ok(channel.connect().await?) Ok(channel.connect().await?)
} }
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI-generated.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI.h

Loading...
View Options

native/schema/CommCoreModuleSchema.js

Loading...