热门
立即入驻

iPhone通过Shortcut(捷径)将验证码短信发送到Windows/macOS电脑

亲测源码12小时前发布 admin
4 00
🌐 经济型：买域名、轻量云服务器、用途：游戏 网站等 《腾讯云》特点：特价机便宜 适合初学者用 点我优惠购买
🚀 拓展型：买域名、轻量云服务器、用途：游戏 网站等 《阿里云》特点：中档服务器便宜 域名备案事多 点我优惠购买
🛡️ 稳定型：买域名、轻量云服务器、用途：游戏 网站等 《西部数码》 特点：比上两家略贵但是稳定性超好事也少 点我优惠购买

功能说明
通过 IOS Shortcut的Automation功能，在收到验证码短信的时候，解析数字验证码，并将其发送到【同 wifi 网络下】电脑(windows/macos)的监听服务中，程序会自动复制到系统剪切板，我们只需要ctrl + v粘贴就可以了。

如果你使用mac，可以不用看了，你可以通过iphone message 自带的 Text Message Forwarding功能，在mac上直接看到验证码。但是我不喜欢这个功能，因为它会把所有的短信都转发，有泄露隐私的风险。

写在前面(为什么做这个)
最近被气死！
重装了windows系统，在重新登陆很多网站的时候发现即使输入了账户密码，网站还是要求要验证码验证。 要不停在手机和电脑屏幕间切换，一下子就把想专注工作的心思打碎了。
为了避免下次重装再被气死，也方便有同样需求的网友，于是就有了这个帖子，因为最近在学习rust，所以这个算是用rust写的练手项目。

如何使用
1. 安装我的工作流(https://www.icloud.com/shortcuts/750e2f275d464e9da34812eabc289d74)或者看图自己设置：
iPhone通过Shortcut(捷径)将验证码短信发送到Windows/macOS电脑
2.  让iPhone和电脑连接同个网络(wifi)；
3. 在电脑运行我的程序 sms_notification，sms_notification 使用 rust 编写:你根据平台可以下载附件中的【macOS版本】或【Windows版本】并运行(默认端口8080，当然你也可以在启动程序时传入不同的端口号)：
包含mac和windows链接：https://pan.quark.cn/s/51a2245d6fe8
当然，你也可以下载代码自行编译【源码和cargo.toml】然后运行；
4. 在运行 sms_notification 的电脑获取电脑的局域网ip（比如 192.168.3.232）：Windows： 使用命令 ipconfig /all 找到本地 ipv4 地址;macOS: 使用命令 ifconfig -a 找到本地 ipv4 地址；修改【工作流】中的 Text 中 网址部分的 ip；
5. 找个发送短信的网页(比如豆包)尝试验证码登陆；
效果展示
iPhone通过Shortcut(捷径)将验证码短信发送到Windows/macOS电脑
源码
如需自行编译，请使用cargo新建一个项目，并使用下方代码替换你的main.rs， cargo.toml。然后使用命令 cargo build –release编译release版本
main.rs

  1. use clap::Parser;
  2. use tracing::{info, error};
  3. use tokio::sync::mpsc;
  4. use std::convert::Infallible;
  5. use warp::Filter;
  7. #[derive(Parser, Debug)]
  8. #[command(name = “sms_notification”)]
  9. #[command(about = “HTTP server that copies SMS to clipboard and shows notifications”)]
  10. struct Args {
  11.     #[arg(short, long, default_value_t = 8080)]
  12.     port: u16,
  13. }
  15. #[derive(Clone)]
  16. struct AppState {
  17.     sms_tx: mpsc::Sender<String>,
  18. }
  20. async fn handle_sms(
  21.     query: std::collections::HashMap<String, String>,
  22.     state: AppState,
  23. ) -> Result<impl warp::Reply, Infallible> {
  24.     if let Some(sms) = query.get(“sms”) {
  25.         let sms_clone = sms.clone();
  26.         if state.sms_tx.send(sms_clone).await.is_err() {
  27.             error!(“Failed to send SMS to notification handler”);
  28.         }
  29.         info!(“Received SMS: {}”, sms);
  30.         println!(“sms: {}”, sms);
  31.         Ok(warp::reply::html(format!(“SMS received: {}”, sms)))
  32.     } else {
  33.         Ok(warp::reply::html(“Usage: GET /?sms=<message>”.to_string()))
  34.     }
  35. }
  37. async fn start_http_server(port: u16, sms_tx: mpsc::Sender<String>) {
  38.     let state = AppState { sms_tx };
  39.     let route = warp::path::end()
  40.         .and(warp::get())
  41.         .and(warp::query::<std::collections::HashMap<String, String>>())
  42.         .and(with_state(state))
  43.         .and_then(handle_sms);
  45.     let (_, server) = warp::serve(route)
  46.         .bind_with_graceful_shutdown(([0, 0, 0, 0], port), async {
  47.             tokio::time::sleep(tokio::time::Duration::MAX).await
  48.         });
  50.     info!(“HTTP server listening on port {}”, port);
  51.     server.await;
  52. }
  54. fn with_state(state: AppState) -> impl Filter<Extract = (AppState,), Error = Infallible> + Clone {
  55.     warp::any().map(move || state.clone())
  56. }
  58. fn copy_to_clipboard(text: &str) -> bool {
  59.     match arboard::Clipboard::new() {
  60.         Ok(mut clipboard) => {
  61.             match clipboard.set_text(text) {
  62.                 Ok(_) => {
  63.                     info!(“Copied to clipboard: {}”, text);
  64.                     true
  65.                 }
  66.                 Err(e) => {
  67.                     error!(“Failed to set clipboard: {:?}”, e);
  68.                     false
  69.                 }
  70.             }
  71.         }
  72.         Err(e) => {
  73.             error!(“Failed to open clipboard: {:?}”, e);
  74.             false
  75.         }
  76.     }
  77. }
  79. fn show_dialog(title: &str, body: &str) {
  80.     let result = rfd::MessageDialog::new()
  81.         .set_title(title)
  82.         .set_description(body)
  83.         .show();
  84.     if !result {
  85.         error!(“Failed to show dialog: show() returned false”);
  86.     } else {
  87.         info!(“Dialog shown: {} – {}”, title, body);
  88.     }
  89. }
  91. fn main() {
  92.     // Parse CLI
  93.     let args = Args::parse();
  95.     // Setup logging to file + stdout
  96.     let log_file = std::fs::File::create(“sms_notification.log”).unwrap();
  97.     let (non_blocking, _guard) = tracing_appender::non_blocking(log_file);
  98.     tracing_subscriber::fmt()
  99.         .with_writer(non_blocking)
  100.         .with_ansi(false)
  101.         .init();
  103.     info!(“SMS Notification App starting on port {}”, args.port);
  105.     // Shared state for last SMS (for tray click -> clipboard)
  106.     use std::sync::Arc;
  107.     use tokio::sync::Mutex;
  108.     let last_sms = Arc::new(Mutex::new(String::new()));
  109.     let (sms_tx, mut sms_rx) = mpsc::channel::<String>(100);
  111.     // Clipboard channel receiver — runs in background thread
  112.     let last_sms_for_receiver = last_sms.clone();
  113.     std::thread::spawn(move || {
  114.         let rt = tokio::runtime::Runtime::new().unwrap();
  115.         rt.block_on(async {
  116.             while let Some(sms) = sms_rx.recv().await {
  117.                 *last_sms_for_receiver.lock().await = sms.clone();
  118.                 copy_to_clipboard(&sms);
  119.                 // Show notification in a separate thread to avoid blocking the receiver
  120.                 let sms_for_notify = sms.clone();
  121.                 std::thread::spawn(move || {
  122.                     show_dialog(“SMS Received”, &sms_for_notify);
  123.                 });
  124.             }
  125.         });
  126.     });
  128.     // Spawn HTTP server
  129.     let http_port = args.port;
  130.     let sms_tx_clone = sms_tx.clone();
  131.     std::thread::spawn(move || {
  132.         let rt = tokio::runtime::Runtime::new().unwrap();
  133.         rt.block_on(start_http_server(http_port, sms_tx_clone));
  134.     });
  136.     // Build SystemTray with menu
  137.     use tao::{
  138.         menu::{ContextMenu, MenuItemAttributes, MenuId},
  139.         system_tray::{SystemTrayBuilder, Icon},
  140.         event_loop::{EventLoop, ControlFlow, EventLoopWindowTarget},
  141.     };
  143.     // Create a simple 1×1 icon (solid color)
  144.     let icon_data = vec![0u8; 4]; // RGBA: all zeros = transparent black
  145.     let icon = Icon::from_rgba(icon_data, 1, 1).expect(“Failed to create icon”);
  147.     // Build context menu
  148.     let mut menu = ContextMenu::new();
  149.     let about_item = MenuItemAttributes::new(“About”)
  150.         .with_id(MenuId::new(“about”));
  151.     let log_item = MenuItemAttributes::new(“Log”)
  152.         .with_id(MenuId::new(“log”));
  153.     let exit_item = MenuItemAttributes::new(“Exit”)
  154.         .with_id(MenuId::new(“exit”));
  155.     menu.add_item(about_item);
  156.     menu.add_item(log_item);
  157.     menu.add_item(exit_item);
  159.     // Create EventLoop and build SystemTray
  160.     let event_loop: EventLoop<()> = EventLoop::new();
  161.     let window_target: &EventLoopWindowTarget<()> = &event_loop;
  163.     let _system_tray = SystemTrayBuilder::new(icon, Some(menu))
  164.         .with_tooltip(“SMS Notification”)
  165.         .build(window_target)
  166.         .expect(“Failed to build system tray”);
  168.     let last_sms_for_tray = last_sms.clone();
  170.     event_loop.run(move |event, _, control_flow| {
  171.         use tao::event::Event;
  172.         use tao::event::TrayEvent as TrayEventType;
  173.         match event {
  174.             Event::TrayEvent { event: TrayEventType::LeftClick, .. } => {
  175.                 // Tray icon left click – copy last SMS to clipboard
  176.                 let last = last_sms_for_tray.clone();
  177.                 std::thread::spawn(move || {
  178.                     let rt = tokio::runtime::Runtime::new().unwrap();
  179.                     rt.block_on(async {
  180.                         let sms = last.lock().await;
  181.                         if !sms.is_empty() {
  182.                             copy_to_clipboard(&sms);
  183.                             show_dialog(“SMS Copied”, &sms);
  184.                         }
  185.                     });
  186.                 });
  187.             }
  188.             Event::MenuEvent { menu_id, .. } => {
  189.                 // Menu item clicked – compare by creating MenuId from same strings
  190.                 let about_id = MenuId::new(“about”);
  191.                 let log_id = MenuId::new(“log”);
  192.                 let exit_id = MenuId::new(“exit”);
  193.                 if menu_id == about_id {
  194.                     let about_text = format!(“SMS Notification App\nVersion 0.1.0\nPort: {}”, args.port);
  195.                     std::thread::spawn(move || {
  196.                         show_dialog(“About SMS Notification”, &about_text);
  197.                     });
  198.                 } else if menu_id == log_id {
  199.                     std::thread::spawn(move || {
  200.                         if let Ok(log_content) = std::fs::read_to_string(“sms_notification.log”) {
  201.                             let lines: Vec<&str> = log_content.lines().rev().take(20).collect();
  202.                             show_dialog(“Recent Logs”, &lines.join(“\n”));
  203.                         } else {
  204.                             show_dialog(“Logs”, “No logs found.”);
  205.                         }
  206.                     });
  207.                 } else if menu_id == exit_id {
  208.                     std::process::exit(0);
  209.                 }
  210.             }
  211.             _ => {}
  212.         }
  213.         *control_flow = ControlFlow::Wait;
  214.     });
  215. }
复制代码

cargo.toml

  1. [package]
  2. name = “sms_notification”
  3. version = “0.1.0”
  4. edition = “2021”
  6. [dependencies]
  7. tokio = { version = “1”, features = [“full”] }
  8. warp = “0.3”
  9. tao = { version = “0.18”, features = [“tray”] }
  10. arboard = “3”
  11. tracing = “0.1”
  12. tracing-subscriber = { version = “0.3”, features = [“env-filter”] }
  13. tracing-appender = “0.2”
  14. clap = { version = “4”, features = [“derive”] }
  15. rfd = “0.11”
  17. [profile.release]
  18. strip = true
  19. lto = true
复制代码

 

该资源来源于WordPress主站，点击下方按钮前往原文页面获取完整内容：

跳转至 WordPress 主站原文页面

© 版权声明
文章版权归作者所有，未经允许请勿转载。

相关文章

添加小工具
点此为“正文侧边栏”添加小工具