近两年来工信部对于应用的隐私合规安全问题愈加重视，对 Android 平台的管控程度也要比 IOS 平台严格很多，很多不合规的应用也先后被下架要求整改。笔者就曾遇到过加班整改隐私合规的问题，隐私合规问题主要针对两个方面。
IMEI、AndroidId、MAC 等针对上述两个方面，有以下措施来针对
通过定义注解和工具类，用来定义要处理哪些隐私合规相关的方法，目前笔者已经处理了大部分，请放心食用
/**
* 收集和注解匹配的方法
* visitMethodInsn(int opcode, String owner, String name,String desc)
*
* ======如果 originName 和 originDesc 传""，逻辑会在插件中处理=====
*/
@Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD})
public @interface AsmMethodReplace {
/**
* 指令操作码
*/
int targetMethodOpcode();
/**
* 方法所有者类
*/
String targetClass();
/**
* 方法名称
*/
String targetName() default "";
/**
* 方法描述符
*/
String targetDesc() default "";
/**
* 是否进行 hook
*/
boolean hook() default false;
}该注解用来匹配调用隐私合规 api 的字节码指令，例如通过 ASM 调用 getImei 的字节码指令为methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "android/telephony/TelephonyManager", "getImei", "()Ljava/lang/String;", false);。targetName属性和 targetDesc 可以不赋值，这里做了取巧的处理，会根据工具类的 method name 和method descriptor 推断出调用隐私合规方法的字节码指令，这块后面插件会处理。最后的 hook 属性表示是否 hook 掉原始的调用链，将调用指向工具类中的方法。
上述注解可以用在任何地方，笔者将常用的隐私合规的方法聚合起来，方法工具类中统一处理，例如处理 IMEI 的逻辑如下：
@RequiresApi(api = Build.VERSION_CODES.O)
@AsmMethodReplace(targetMethodOpcode = OPCODE_INVOKEVIRTUAL
, targetClass = CLASS_NAME_TELEPHONYMANAGER,hook = true)
public static String getImei(TelephonyManager telephonyManager) {
if (!checkAgreePrivacy("getImei")) {
Log.e(TAG, TIP);
return "";
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
Log.i(TAG, "getImei-SDK_INT above android Q");
return "";
}
return telephonyManager.getImei();
}如果还没有同意隐私协议，直接 return “”，否者走正常的调用方法。同时，通过工具类
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
ConfigGlobal.getInstance().setStoreDirectory(base.getExternalCacheDir().getAbsolutePath());
}设置存储调用堆栈和时间的文件路径。
gradle 插件的基本使用在这里就不赘述了，这里主要是两方面的处理
下面这块代码是我们在自定义 gradle 插件时常用的模版代码，供大家使用
package com.zhangyue.ireader
import com.android.build.api.transform.*
import com.android.build.gradle.internal.pipeline.TransformManager
import com.zhangyue.ireader.plugin_privacy.PrivacyGlobalConfig
import com.zhangyue.ireader.util.CommonUtil
import com.zhangyue.ireader.util.Logger
import org.apache.commons.io.FileUtils
import org.apache.commons.io.IOUtils
import org.gradle.api.Project
import java.util.concurrent.AbstractExecutorService
import java.util.concurrent.Callable
import java.util.concurrent.ForkJoinPool
import java.util.jar.JarEntry
import java.util.jar.JarFile
import java.util.jar.JarOutputStream
abstract class BaseTransform extends Transform {
AbstractExecutorService executorService = ForkJoinPool.commonPool()
private List<Callable<Void>> taskList = new ArrayList<>()
protected Project project
BaseTransform(Project project) {
this.project = project
}
@Override
String getName() {
return getClass().simpleName
}
@Override
Set<QualifiedContent.ContentType> getInputTypes() {
return TransformManager.CONTENT_CLASS
}
@Override
Set<? super QualifiedContent.Scope> getScopes() {
return TransformManager.SCOPE_FULL_PROJECT
}
@Override
boolean isIncremental() {
return true
}
@Override
void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
super.transform(transformInvocation)
println("transform start--------------->")
if (firstTransform()) {
printCopyRight()
}
onTransformStart(transformInvocation)
def startTime = System.currentTimeMillis()
def inputs = transformInvocation.inputs
def outputProvider = transformInvocation.outputProvider
def context = transformInvocation.context
def isIncremental = transformInvocation.isIncremental()
if (!isIncremental) {
outputProvider.deleteAll()
}
//1
// inputs.each { input ->
// input.jarInputs.each { JarInput jarInput ->
// forEachJar(jarInput, outputProvider, context, isIncremental)
// }
//
// input.directoryInputs.each { DirectoryInput dirInput ->
// forEachDir(dirInput, outputProvider, context, isIncremental)
// }
// }
//3
inputs.each { input ->
input.jarInputs.each { jarInput ->
submitTask(new Runnable() {
@Override
void run() {
forEachJar(jarInput, outputProvider, context, isIncremental)
}
})
}
input.directoryInputs.each { DirectoryInput dirInput ->
submitTask(new Runnable() {
@Override
void run() {
forEachDir(dirInput, outputProvider, context, isIncremental)
}
})
}
}
def futures = executorService.invokeAll(taskList)
futures.each { it ->
it.get()
}
onTransformEnd(transformInvocation)
println(getName() + "transform end--------------->" + "duration : " + (System.currentTimeMillis() - startTime) + " ms")
}
void submitTask(Runnable runnable) {
taskList.add(new Callable<Void>() {
@Override
Void call() throws Exception {
runnable.run()
return null
}
})
}
void forEachDir(DirectoryInput directoryInput, TransformOutputProvider outputProvider, Context context, boolean isIncremental) {
def inputDir = directoryInput.file
File dest = outputProvider.getContentLocation(
directoryInput.name,
directoryInput.contentTypes,
directoryInput.scopes,
Format.DIRECTORY
)
println "directoryInputPath:" + directoryInput.file.absolutePath
println "destPath:" + dest.absolutePath
def srcDirPath = inputDir.absolutePath
def destDirPath = dest.absolutePath
def temporaryDir = context.temporaryDir
FileUtils.forceMkdir(dest)
Logger.info("srcDirPath:${srcDirPath}, destDirPath:${destDirPath}")
if (isIncremental) {
directoryInput.getChangedFiles().each { entry ->
def classFile = entry.key
switch (entry.value) {
case Status.NOTCHANGED:
Logger.info("处理 class： " + classFile.absoluteFile + " NOTCHANGED")
break
case Status.REMOVED:
Logger.info("处理 class： " + classFile.absoluteFile + " REMOVED")
//最终文件应该存放的路径
def destFilePath = classFile.absolutePath.replace(srcDirPath, destDirPath)
def destFile = File(destFilePath)
if (destFile.exists()) {
destFile.delete()
}
break
case Status.ADDED:
case Status.CHANGED:
Logger.info("处理 class： " + classFile.absoluteFile + " ADDED or CHANGED")
modifyClassFile(classFile, srcDirPath, destDirPath, temporaryDir)
break
default:
break
}
}
} else {
com.android.utils.FileUtils.getAllFiles(inputDir).each { File file ->
modifyClassFile(file, srcDirPath, destDirPath, temporaryDir)
}
}
}
void modifyClassFile(classFile, srcDirPath, destDirPath, temporaryDir) {
Logger.info("处理 class： " + classFile.absoluteFile)
//目标路径
def destFilePath = classFile.absolutePath.replace(srcDirPath, destDirPath)
def destFile = new File(destFilePath)
if (destFile.exists()) {
destFile.delete()
}
Logger.info("处理 class：destFile" + destFile.absoluteFile)
String className = CommonUtil.path2ClassName(classFile.absolutePath.replace(srcDirPath + File.separator, ""))
Logger.info("处理 className： " + className)
File modifyFile = null
if (CommonUtil.isLegalClass(classFile) && shouldHookClass(className)) {
modifyFile = getModifyFile(classFile, temporaryDir, className)
}
if (modifyFile == null) {
modifyFile = classFile
}
FileUtils.copyFile(modifyFile, destFile)
}
File getModifyFile(File classFile, File temporaryDir, String className) {
byte[] sourceBytes = IOUtils.toByteArray(new FileInputStream(classFile))
def tempFile = new File(temporaryDir, CommonUtil.generateClassFileName(classFile))
if (tempFile.exists()) {
FileUtils.forceDelete(tempFile)
}
def modifyBytes = modifyClass(className, sourceBytes)
if (modifyBytes == null) {
modifyBytes = sourceBytes
}
tempFile.createNewFile()
def fos = new FileOutputStream(tempFile)
fos.write(modifyBytes)
fos.flush()
IOUtils.closeQuietly(fos)
return tempFile
}
void forEachJar(JarInput jarInput, TransformOutputProvider outputProvider, Context context, boolean isIncremental) {
Logger.info("jarInput:" + jarInput.file)
File destFile = outputProvider.getContentLocation(
//防止同名被覆盖
CommonUtil.generateJarFileName(jarInput.file), jarInput.contentTypes, jarInput.scopes, Format.JAR)
//增量编译处理
if (isIncremental) {
Status status = jarInput.status
switch (status) {
case Status.NOTCHANGED:
Logger.info("处理 jar： " + jarInput.file.absoluteFile + " NotChanged")
//Do nothing
return
case Status.REMOVED:
Logger.info("处理 jar： " + jarInput.file.absoluteFile + " REMOVED")
if (destFile.exists()) {
FileUtils.forceDelete(destFile)
}
return
case Status.ADDED:
case Status.CHANGED:
Logger.info("处理 jar： " + jarInput.file.absoluteFile + " ADDED or CHANGED")
break
}
}
if (destFile.exists()) {
FileUtils.forceDelete(destFile)
}
CommonUtil.isLegalJar(jarInput.file) ? transformJar(jarInput.file, context.getTemporaryDir(), destFile)
: FileUtils.copyFile(jarInput.file, destFile)
}
def transformJar(File jarFile, File temporaryDir, File destFile) {
Logger.info("处理 jar： " + jarFile.absoluteFile)
File tempOutputJarFile = new File(temporaryDir, CommonUtil.generateJarFileName(jarFile))
if (tempOutputJarFile.exists()) {
FileUtils.forceDelete(tempOutputJarFile)
}
JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(tempOutputJarFile))
JarFile inputJarFile = new JarFile(jarFile, false)
try {
def entries = inputJarFile.entries()
while (entries.hasMoreElements()) {
def jarEntry = entries.nextElement()
def entryName = jarEntry.getName()
def inputStream = inputJarFile.getInputStream(jarEntry)
try {
byte[] sourceByteArray = IOUtils.toByteArray(inputStream)
def modifiedByteArray = null
if (!jarEntry.isDirectory() && CommonUtil.isLegalClass(entryName)) {
String className = CommonUtil.path2ClassName(entryName)
if (shouldHookClass(className)) {
modifiedByteArray = modifyClass(className, sourceByteArray)
}
}
if (modifiedByteArray == null) {
modifiedByteArray = sourceByteArray
}
jarOutputStream.putNextEntry(new JarEntry(entryName))
jarOutputStream.write(modifiedByteArray)
jarOutputStream.closeEntry()
} finally {
IOUtils.closeQuietly(inputStream)
}
}
} finally {
jarOutputStream.flush()
IOUtils.closeQuietly(jarOutputStream)
IOUtils.closeQuietly(inputJarFile)
}
FileUtils.copyFile(tempOutputJarFile, destFile)
}
private byte[] modifyClass(String className, byte[] sourceBytes) {
byte[] classBytesCode
try {
classBytesCode = hookClassInner(className, sourceBytes)
} catch (Throwable e) {
e.printStackTrace()
classBytesCode = null
println "throw exception when modify class ${className}"
}
return classBytesCode
}
/**
* 打印日志信息
*/
static void printCopyRight() {
println()
println '#######################################################################'
println '########## '
println '########## 欢迎使用隐私合规处理插件'
println '########## '
println '#######################################################################'
println '########## '
println '########## 插件配置参数 '
println '########## '
println '########## -isDebug: ' + PrivacyGlobalConfig.isDebug
println '########## -handleAnnotationName: ' + PrivacyGlobalConfig.handleAnnotationName
println '########## -exclude: ' + PrivacyGlobalConfig.exclude
println '########## '
println '########## '
println '########## '
println '#######################################################################'
println()
}
protected boolean firstTransform() {
return false
}
boolean shouldHookClass(String className) {
def excludes = PrivacyGlobalConfig.exclude
if (excludes != null) {
for (String string : excludes) {
if (className.startsWith(string)) {
return false
}
}
}
return shouldHookClassInner(className)
}
protected abstract boolean shouldHookClassInner(String className)
protected abstract byte[] hookClassInner(String className, byte[] bytes)
protected abstract void onTransformStart(TransformInvocation transformInvocation)
protected abstract void onTransformEnd(TransformInvocation transformInvocation)
}收集和处理具有特定注解的字节码指令,给下一个 transform 使用
@Override
byte[] hookClassInner(String className, byte[] bytes) {
ClassReader cr = new ClassReader(bytes)
ClassNode classNode = new ClassNode()
cr.accept(classNode, 0)
classNode.methods.each { methodNode ->
//编译期注解
methodNode.invisibleAnnotations.
each { annotationNode ->
if (PrivacyGlobalConfig.getHandleAnnotationName() == annotationNode.desc) {
collectPrivacyMethod(annotationNode, methodNode, cr.className)
}
}
}
return bytes
}
/**
* 收集注解和注解关联的方法
* @param annotationNode 注解信息
* @param methodNode 方法信息
*/
static collectPrivacyMethod(AnnotationNode annotationNode, MethodNode methodNode, String className) {
List<Object> values = annotationNode.values
Logger.info("annotation values : ${values}")
MethodReplaceItem item = new MethodReplaceItem(values, methodNode, CommonUtil.getClassInternalName(className))
PrivacyGlobalConfig.methodReplaceItemList.offer(item)
Logger.info("collectPrivacyMethod success: ${item}")
println("collectPrivacyMethod success: ${item}")
}MethodReplaceItem中封装了收集到的字节码属性，同时会根据注解关联方法的字节码指令推断出想要处理的隐私合规 api 的字节码指令。
MethodReplaceItem(List<Object> annotationPair, MethodNode methodNode, String owner) {
replaceOpcode = Opcodes.INVOKESTATIC
replaceClass = owner
replaceMethod = methodNode.name
replaceDesc = methodNode.desc
for (int i = 0; i < annotationPair.size(); i = i + 2) {
def key = annotationPair[i]
def value = annotationPair[i + 1]
if (key == "targetMethodOpcode") {
targetOpcode = value
} else if (key == "targetClass") {
targetOwner = value
} else if (key == "targetName") {
targetMethod = value
} else if (key == "targetDesc") {
targetDesc = value
}else if(key == "hook"){
willHook = value
}
}
Logger.info("=====targetOpcode:${targetOpcode},targetOwner:${targetOwner} , replaceDesc${replaceDesc}")
if (isEmpty(targetMethod)) {
targetMethod = replaceMethod
}
if (isEmpty(targetDesc)) {
//静态方法，oriDesc 跟 targetDesc 一样
if (targetOpcode == Opcodes.INVOKESTATIC) {
targetDesc = replaceDesc
} else {
//非静态方法，约定第一个参数是实例类名，oriDesc 比 targetDesc 少一个参数，处理一下
// (Landroid/telephony/TelephonyManager;)Ljava/lang/String -> ()Ljava/lang/String
def param = replaceDesc.split('\)')[0] + ")"
def result = replaceDesc.split('\)')[1]
def index = replaceDesc.indexOf(targetOwner)
if (index != -1) {
param = "(" + param.substring(index + targetOwner.length() + 1)
}
Logger.info("index::: ${index}")
targetDesc = param + result
}
}
}再次扫描整个项目，根据在上一个 transform 中收集到的要处理的隐私合规的 api，遍历字节码指令，当匹配上时，在当前的类中注入写文件的方法，同时在调用隐私合规的字节码指令前插入写文件的字节码指令，用来记录。
@Override
byte[] hookClassInner(String className, byte[] bytes) {
Logger.info("${getName()} modifyClassInner--------------->")
def findHookPoint = false
Map<MethodNode, InsertInsnPoint> collectMap = new HashMap<>()
ClassReader cr = new ClassReader(bytes)
ClassNode classNode = new ClassNode()
cr.accept(classNode, ClassReader.EXPAND_FRAMES)
classNode.methods.each { methodNode ->
//过滤掉含有特定注解的方法
if (isNotHookMethod(cr.className, methodNode)) {
methodNode.instructions.each { insnNode ->
//判断字节码能否匹配
def methodReplaceItem = searchHookPoint(insnNode)
if (methodReplaceItem != null) {
//判断是否需要 hook 掉当前指令
def inject = methodReplaceItem.willHook
//记录隐私合规 api 所在的类及方法
logHookPoint(classNode.name, methodReplaceItem, methodNode, insnNode.opcode, insnNode.owner, insnNode.name, insnNode.desc, inject)
if (inject) {
//hook
injectInsn(insnNode, methodReplaceItem)
}
//插入写文件方法指令，收集调用隐私方法的堆栈
collectInsertInsn(insnNode, methodNode, classNode, collectMap, inject)
findHookPoint = true
}
}
}
}
if (!collectMap.isEmpty() && findHookPoint) {
//插入写文件指令，用来展示堆栈信息
collectMap.each { key, value ->
key.instructions.insert(value.hookInsnNode, value.instList)
}
//插入 writeToFile 方法
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS)
classNode.accept(cw)
insertWriteToFileMethod(cw)
return cw.toByteArray()
}
return bytes
}在 collectInsertInsn 方法中，通过 throwable来收集当前的堆栈
/**
* 收集 在调用特定的方法前插入调用写入文件的方法的指令
* @param insnNode
* @param methodNode
* @param classNode
* @param collectMap
*/
static void collectInsertInsn(insnNode, methodNode, classNode, collectMap, Inject) {
def className = classNode.name
def methodName = methodNode.name
def methodDesc = methodNode.desc
def owner = null
def name = null
def desc = null
if (insnNode instanceof MethodInsnNode) {
owner = insnNode.owner
name = insnNode.name
desc = insnNode.desc
}
//------log
StringBuilder lintLog = new StringBuilder()
lintLog.append(className)
lintLog.append(" -> ")
lintLog.append(methodName)
lintLog.append(" -> ")
lintLog.append(methodDesc)
lintLog.append("\r\n")
lintLog.append(owner)
lintLog.append(" -> ")
lintLog.append(name)
lintLog.append(" -> ")
lintLog.append(desc)
//------要插入字节码指令
lintLog.append("\r\n")
InsnList insnList = new InsnList()
insnList.add(new LdcInsnNode(lintLog.toString()))
insnList.add(new TypeInsnNode(Opcodes.NEW, "java/lang/Throwable"))
insnList.add(new InsnNode(Opcodes.DUP))
insnList.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, "java/lang/Throwable", "<init>", "()V", false))
insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, className, writeToFileMethodName, writeToFileMethodDesc))
println "插入指令完成 =---------->"
collectMap.put(methodNode, new InsertInsnPoint(insnList, insnNode))
}最终，在项目编译完成之后，会在项目的根目录下生成 replaceInsn.txt文件，记录包含隐私合规 api 的类和相关方法。
当项目运行起来之后，会在设置的路径中（笔者设置在 getExternalCacheDir 中）生成 privacy_log.txt 文件，里面会记录隐私合规 api 的调用堆栈和时间，根据该调用链，我们就可以快速定位是哪一块业务执行了敏感操作。
通过 ASM + gradle plugin ，能够排查出大部分的隐私合规问题。有什么不足之处，也请读者多多提意见和建议。
改项目已经在 github 上开源，希望大家多多围观。https://github.com/season-max/asm_hook.git
参考链接：
本文由哈喽比特于1年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/5hN4L0l3OFcVVkU4RJXYJA
京东创始人刘强东和其妻子章泽天最近成为了互联网舆论关注的焦点。有关他们“移民美国”和在美国购买豪宅的传言在互联网上广泛传播。然而，京东官方通过微博发言人发布的消息澄清了这些传言，称这些言论纯属虚假信息和蓄意捏造。
日前，据博主“@超能数码君老周”爆料，国内三大运营商中国移动、中国电信和中国联通预计将集体采购百万台规模的华为Mate60系列手机。
据报道，荷兰半导体设备公司ASML正看到美国对华遏制政策的负面影响。阿斯麦（ASML）CEO彼得·温宁克在一档电视节目中分享了他对中国大陆问题以及该公司面临的出口管制和保护主义的看法。彼得曾在多个场合表达了他对出口管制以及中荷经济关系的担忧。
今年早些时候，抖音悄然上线了一款名为“青桃”的 App，Slogan 为“看见你的热爱”，根据应用介绍可知，“青桃”是一个属于年轻人的兴趣知识视频平台，由抖音官方出品的中长视频关联版本，整体风格有些类似B站。
日前，威马汽车首席数据官梅松林转发了一份“世界各国地区拥车率排行榜”，同时，他发文表示：中国汽车普及率低于非洲国家尼日利亚，每百户家庭仅17户有车。意大利世界排名第一，每十户中九户有车。
近日，一项新的研究发现，维生素 C 和 E 等抗氧化剂会激活一种机制，刺激癌症肿瘤中新血管的生长，帮助它们生长和扩散。
据媒体援引消息人士报道，苹果公司正在测试使用3D打印技术来生产其智能手表的钢质底盘。消息传出后，3D系统一度大涨超10%，不过截至周三收盘，该股涨幅回落至2%以内。
9月2日，坐拥千万粉丝的网红主播“秀才”账号被封禁，在社交媒体平台上引发热议。平台相关负责人表示，“秀才”账号违反平台相关规定，已封禁。据知情人士透露，秀才近期被举报存在违法行为，这可能是他被封禁的部分原因。据悉，“秀才”年龄39岁，是安徽省亳州市蒙城县人，抖音网红，粉丝数量超1200万。他曾被称为“中老年...
9月3日消息，亚马逊的一些股东，包括持有该公司股票的一家养老基金，日前对亚马逊、其创始人贝索斯和其董事会提起诉讼，指控他们在为 Project Kuiper 卫星星座项目购买发射服务时“违反了信义义务”。
据消息，为推广自家应用，苹果现推出了一个名为“Apps by Apple”的网站，展示了苹果为旗下产品（如 iPhone、iPad、Apple Watch、Mac 和 Apple TV）开发的各种应用程序。
特斯拉本周在美国大幅下调Model S和X售价，引发了该公司一些最坚定支持者的不满。知名特斯拉多头、未来基金（Future Fund）管理合伙人加里·布莱克发帖称，降价是一种“短期麻醉剂”，会让潜在客户等待进一步降价。
据外媒9月2日报道，荷兰半导体设备制造商阿斯麦称，尽管荷兰政府颁布的半导体设备出口管制新规9月正式生效，但该公司已获得在2023年底以前向中国运送受限制芯片制造机器的许可。
近日，根据美国证券交易委员会的文件显示，苹果卫星服务提供商 Globalstar 近期向马斯克旗下的 SpaceX 支付 6400 万美元（约 4.65 亿元人民币）。用于在 2023-2025 年期间，发射卫星，进一步扩展苹果 iPhone 系列的 SOS 卫星服务。
据报道，马斯克旗下社交平台𝕏（推特）日前调整了隐私政策，允许 𝕏 使用用户发布的信息来训练其人工智能（AI）模型。新的隐私政策将于 9 月 29 日生效。新政策规定，𝕏可能会使用所收集到的平台信息和公开可用的信息，来帮助训练 𝕏 的机器学习或人工智能模型。
9月2日，荣耀CEO赵明在采访中谈及华为手机回归时表示，替老同事们高兴，觉得手机行业，由于华为的回归，让竞争充满了更多的可能性和更多的魅力，对行业来说也是件好事。
《自然》30日发表的一篇论文报道了一个名为Swift的人工智能（AI）系统，该系统驾驶无人机的能力可在真实世界中一对一冠军赛里战胜人类对手。
近日，非营利组织纽约真菌学会（NYMS）发出警告，表示亚马逊为代表的电商平台上，充斥着各种AI生成的蘑菇觅食科普书籍，其中存在诸多错误。
社交媒体平台𝕏（原推特）新隐私政策提到：“在您同意的情况下，我们可能出于安全、安保和身份识别目的收集和使用您的生物识别信息。”
2023年德国柏林消费电子展上，各大企业都带来了最新的理念和产品，而高端化、本土化的中国产品正在不断吸引欧洲等国际市场的目光。
罗永浩日前在直播中吐槽苹果即将推出的 iPhone 新品，具体内容为：“以我对我‘子公司’的了解，我认为 iPhone 15 跟 iPhone 14 不会有什么区别的，除了序（列）号变了，这个‘不要脸’的东西，这个‘臭厨子’。
